﻿using System;
using System.Linq.Expressions;

namespace Entropy.Ext
{
	public interface IExtFactory
	{
		// 
		/// <summary>
		/// 
		/// </summary>
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4 </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// AbstractContainer
		/// <param name="items">Object/Object[]
		/// A single item, or an array of child Components to be added to this container
		/// Unless configured with a layout, a Container simply renders child Components serially into its encapsulating element and performs no sizing or positioning upon them.</param>
		/// <param name="layout"> Ext.enums.Layout/Object
		/// Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specified through the layout configuration option.
		/// The sizing and positioning of child items is the responsibility of the Container's layout manager which creates and manages the type of layout you have in mind. For example:
		/// If the layout configuration is not explicitly specified for a general purpose container (e.g. Container or Panel) the default layout manager will be used which does nothing 
		/// but render child components sequentially into the Container (no sizing or positioning will be performed in this situation).</param>
		/// 
		/// 
		///  Ext.panel.AbstractPanel
		/// 
		///  <param name="baseCls">The base CSS class to apply to this panel's element. Defaults to: x-panel. Available since: Ext 2</param>
		///  <param name="bodyCls">String/String[]. CSS class, space-delimited string of classes, or array of classes to be applied to the panel's body element. 
		///  The following examples are all valid: 
		///  bodyCls: 'foo'    
		///  bodyCls: 'foo bar'  
		///  bodyCls: ['foo', 'bar']</param>
		///  <param name="bodyPadding">A shortcut for setting a padding style on the body element. The value can either be a number to be applied to all sides, 
		///  or a normal css string describing padding. Defaults to undefined.</param>
		/// <param name="bodyStyle">String/Object/Function2
		/// Custom CSS styles to be applied to the panel's body element, which can be supplied as a valid CSS style string, an object containing style property name/value pairs or 
		/// a function that returns such a string or object.</param>
		/// <param name="border">Number/String/Boolean2
		/// Specifies the border size for this component. 
		/// The border can be a single numeric value to apply to all sides or it can be a CSS style specification for each style, for example: '10 5 3 10' (top, right, bottom, left).
		/// For components that have no border by default, setting this won't make the border appear by itself. You also need to specify border color and style</param>
		/// 
		/// Component
		/// <param name="region">
		/// "north"/"south"/"east"/"west"/"center"
		/// Defines the region inside border layout.
		/// Possible values:
		/// north - Positions component at top.
		/// south - Positions component at bottom.
		/// east - Positions component at right.
		/// west - Positions component at left.
		/// center - Positions component at the remaining space. 
		/// There must be a component with region: "center" in every border layout.
		/// Available since: Ext 4.1.1</param> 
		/// 
		/// panel.Panel
		/// 
		/// <param name="collapsible">True to make the panel collapsible and have an expand/collapse toggle Tool added into the header tool button area. 
		/// False to keep the panel sized either statically, or by an owning layout manager, with no toggle Tool. When a panel is used in a border layout, 
		/// the floatable option can influence the behavior of collapsing. See collapseMode and collapseDirection</param>
		/// <param name="animCollapse">true to animate the transition when the panel is collapsed, false to skip the animation 
		/// (defaults to true if the Ext.fx.Anim class is available, otherwise false). May also be specified as the animation duration in milliseconds.</param>
		/// <param name="buttons">Object/Object[]
		/// Convenience config used for adding buttons docked to the bottom of the panel. This is a synonym for the fbar config.</param>
		/// <returns></returns>
		IPanelPanel CreatePanelPanel(
            // Ext.panel.AbstractPanel
            string baseCls = null,
            string bodyCls = null,
            Padding bodyPadding = null,
            string bodyStyle = null,
            Border border = null,

			// Ext.AbstractComponent
            int? width = null,
            int? height = null,
			string cls = null, 
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// AbstractContainer
			IBase[] items = null,
			[JsConfig]
            ILayout layout = null,

			// Component
            Region? region = null,

			// panel.panel 
			bool? collapsible = null,
			bool? animCollapse = null,
			IComponent[] buttons = null,

			string title = null, 
            string margins = null,
            bool? split = null,
            int? minSize = null,
            int? maxSize = null,
            string renderTo = null
         );

		/// <summary>
		/// The TreePanel provides tree-structured UI representation of tree-structured data. A TreePanel must be bound to a Ext.data.TreeStore. 
		/// TreePanel's support multiple columns through the columns configuration.
		/// </summary>
		/// 
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		///  Ext.panel.AbstractPanel
		/// 
		///  <param name="baseCls">The base CSS class to apply to this panel's element. Defaults to: x-panel. Available since: Ext 2</param>
		///  <param name="bodyCls">String/String[]. CSS class, space-delimited string of classes, or array of classes to be applied to the panel's body element. 
		///  The following examples are all valid: 
		///  bodyCls: 'foo'    
		///  bodyCls: 'foo bar'  
		///  bodyCls: ['foo', 'bar']</param>
		///  <param name="bodyPadding">A shortcut for setting a padding style on the body element. The value can either be a number to be applied to all sides, 
		///  or a normal css string describing padding. Defaults to undefined.</param>
		/// <param name="bodyStyle">String/Object/Function2
		/// Custom CSS styles to be applied to the panel's body element, which can be supplied as a valid CSS style string, an object containing style property name/value pairs or 
		/// a function that returns such a string or object.</param>
		/// <param name="border">Number/String/Boolean2
		/// Specifies the border size for this component. 
		/// The border can be a single numeric value to apply to all sides or it can be a CSS style specification for each style, for example: '10 5 3 10' (top, right, bottom, left).
		/// For components that have no border by default, setting this won't make the border appear by itself. You also need to specify border color and style</param>
		/// 
		/// Component
		/// 
		/// <param name="region">
		/// "north"/"south"/"east"/"west"/"center"
		/// Defines the region inside border layout.
		/// Possible values:
		/// north - Positions component at top.
		/// south - Positions component at bottom.
		/// east - Positions component at right.
		/// west - Positions component at left.
		/// center - Positions component at the remaining space. 
		/// There must be a component with region: "center" in every border layout.
		/// Available since: Ext 4.1.1</param>
		/// 
		/// Panel
		/// 
		/// <param name="bbar">Convenience config. Short for 'Bottom Bar'.
		/// Available since: Ext 2</param>
		/// 
		/// panel.Table
		/// 
		/// <param name="features">Ext.grid.feature.Feature[]/Object[]/Ext.enums.Feature[]
		/// An array of grid Features to be added to this grid. Can also be just a single feature instead of array.
		/// Features config behaves much like plugins. A feature can be added by either directly referencing the instance:
		/// features: [Ext.create('Ext.grid.feature.GroupingSummary', {groupHeaderTpl: 'Subject: {name}'})],
		/// By using config object with ftype: features: [{ftype: 'groupingsummary', groupHeaderTpl: 'Subject: {name}'}],
		/// Or with just a ftype: features: ['grouping', 'groupingsummary'],
		/// See Ext.enums.Feature for list of all ftypes.
		/// Available since: Ext 4</param>
		/// <param name="plugins"> Ext.AbstractPlugin[]/Object[]/Ext.enums.Plugin[]
		/// An array of plugins to be added to this component. Can also be just a single plugin instead of array.
		/// Plugins provide custom functionality for a component. The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. 
		/// When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself. Each plugin can 
		/// then call methods or respond to events on the component as needed to provide its functionality.
		/// Plugins can be added to component by either directly referencing the plugin instance:
		/// plugins: [Ext.create('Ext.grid.plugin.CellEditing', {clicksToEdit: 1})],
		/// By using config object with ptype:
		/// plugins: [{ptype: 'cellediting', clicksToEdit: 1}],
		/// Or with just a ptype:
		/// plugins: ['cellediting', 'gridviewdragdrop'],
		/// See Ext.enums.Plugin for list of all ptypes.
		/// Available since: Ext 2</param>
		/// <param name="selModel">Ext.selection.Model/Object
		/// A selection model instance or config object. In latter case the selType config option determines to which type of selection model this config is applied.
		/// Available since: Ext 4</param>
		///   
		///  tree.Panel
		/// 
		/// <param name="store">Boolean
		/// True if only 1 node per branch may be expanded.
		/// Defaults to: false
		/// Available since: Ext 1</param>
		/// <param name="useArrows">Boolean
		/// True to use Vista-style arrows in the tree.
		/// Defaults to: false
		/// Available since: Ext 2</param>
		/// <param name="rootVisible"> Boolean
		/// False to hide the root node.
		/// Defaults to: true
		/// Available since: Ext 1</param>
		/// <param name="singleExpand">Boolean
		/// True if only 1 node per branch may be expanded.
		/// Defaults to: false
		/// Available since: Ext 1</param>
		/// 
		/// <returns></returns>
		ITreePanel CreateTreePanel(
            // Ext.panel.AbstractPanel
            string baseCls = null,
            string bodyCls = null,
            Padding bodyPadding = null,
            string bodyStyle = null,
            Border border = null,

            // Ext.AbstractComponent
            int? width = null,
            int? height = null,
            string cls = null,
            string style = null,
            string html = null,
            string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// Ext.Component
            Region? region = null,


			// Ext.panel.Panel
			IToolbar bbar = null,

			// Ext.panel.Table
			IGridFeature[] features = null,
			IPlugin[] plugins = null,
			ISelectionModel selModel = null,


            string title = null,
            ILayout layout = null,
            string margins = null,
            bool? split = null,
            IBase[] items = null,
            bool? collapsible = null,
            bool? animCollapse = null,
            int? minSize = null,
            int? maxSize = null,

			// tree.Panel
			ITreeStore store = null,
			bool? useArrows = null,
			bool? rootVisible = null,
			bool? singleExpand = null
         );

		/// <summary>
		/// Barebones iframe implementation. For serious iframe work, see the ManagedIFrame extension (http://www.sencha.com/forum/showthread.php?71961).
		/// Available since: Ext 4.1.0
		/// </summary>
		///  
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 		
		/// Component
		/// <param name="region">
		/// "north"/"south"/"east"/"west"/"center"
		/// Defines the region inside border layout.
		/// Possible values:
		/// north - Positions component at top.
		/// south - Positions component at bottom.
		/// east - Positions component at right.
		/// west - Positions component at left.
		/// center - Positions component at the remaining space. 
		/// There must be a component with region: "center" in every border layout.
		/// Available since: Ext 4.1.1</param>
		/// 
		/// <returns></returns>
		IFrame CreateIFrame(
            // Ext.AbstractComponent
            int? width = null,
            int? height = null,
            string cls = null,
            string style = null,
            string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// Ext.Component
            Region? region = null
		);

	    IViewport CreateViewport(
            ILayout layout = null,
            string title = null,
            Region? region = null,
            IComponent[] items = null 
        );

		IDataField DataField(
			string name = null,
			FieldType type = FieldType.Auto,
            bool? useNull = null, 
			string dateFormat = null);

	    /// <summary></summary>
	    /// 
	    /// 
	    /// Data.AbstractStore
	    /// 
	    /// <param name="storeId">String
	    /// Unique identifier for this store. If present, this Store will be registered with the Ext.data.StoreManager, making it easy to reuse elsewhere.
	    /// Note that when store is instatiated by Controller, the storeId will be overridden by the name of the store.
	    /// Available since: Ext 4</param>
	    /// <param name="defaultProxyType"> String
	    /// The string type of the Proxy to create if none is specified. This defaults to creating a memory proxy. Defaults to: 'memory'</param>
	    /// <param name="model"> String
	    /// Name of the Model associated with this store. The string is used as an argument for Ext.ModelManager.getModel.
	    /// Available since: Ext 4</param>
	    /// <param name="autoLoad"> Boolean/Object
	    /// If data is not specified, and if autoLoad is true or an Object, this store's load method is automatically called after creation. 
	    /// If the value of autoLoad is an Object, this Object will be passed to the store's load method.
	    /// Available since: Ext 2</param>
	    /// <param name="proxy">String/Ext.data.proxy.Proxy/Object
	    /// The Proxy to use for this Store. This can be either a string, a config object or a Proxy instance - see setProxy for details.
	    /// Available since: Ext 1</param>
	    /// <param name="fields">Object[]
	    /// This may be used in place of specifying a model configuration. The fields should be a set of Ext.data.Field configuration objects. 
	    /// The store will automatically create a Ext.data.Model with these fields. In general this configuration option should only be used for 
	    /// simple stores like a two-field store of ComboBox. For anything more complicated, such as specifying a particular id property or associations, 
	    /// a Ext.data.Model should be defined and specified for the model config.
	    /// Available since: Ext 2</param>
	    /// 
	    /// Data.Store
	    /// 
	    /// <param name="remoteSort">True to defer any sorting operation to the server. If false, sorting is done locally on the client.
	    /// Defaults to: false 
	    /// Available since: Ext 1</param>
	    /// <param name="buffered"> Boolean
	    /// Allows the Store to prefetch and cache in a page cache, pages of Records, and to then satisfy loading requirements from this page cache.
	    /// To use buffered Stores, initiate the process by loading the first page. The number of rows rendered are determined automatically, 
	    /// and the range of pages needed to keep the cache primed for scrolling is requested and cached. Example:
	    /// myStore.loadPage(1); // Load page 1
	    /// A PagingScroller is instantiated which will monitor the scrolling in the grid, and refresh the view's rows from the page cache as needed. 
	    /// It will also pull new data into the page cache when scrolling of the view draws upon data near either end of the prefetched data.
	    /// The margins which trigger view refreshing from the prefetched data are 
	    /// Ext.grid.PagingScroller.numFromEdge, Ext.grid.PagingScroller.leadingBufferZone and Ext.grid.PagingScroller.trailingBufferZone.
	    /// The margins which trigger loading more data into the page cache are, leadingBufferZone and trailingBufferZone.
	    /// By default, only 5 pages of data are cached in the page cache, with pages "scrolling" out of the buffer as the view moves down through the dataset. 
	    /// Setting this value to zero means that no pages are ever scrolled out of the page cache, and that eventually the whole dataset may become present in the page cache. 
	    /// This is sometimes desirable as long as datasets do not reach astronomical proportions. 
	    /// Selection state may be maintained across page boundaries by configuring the SelectionModel not to discard records from its collection 
	    /// when those Records cycle out of the Store's primary collection. This is done by configuring the SelectionModel like this:
	    /// selModel: {pruneRemoved: false}
	    /// Defaults to: false
	    /// Available since: Ext 4</param>
	    /// <param name="pageSize">Number
	    /// The number of records considered to form a 'page'. This is used to power the built-in paging using the nextPage and previousPage functions 
	    /// when the grid is paged using a PagingScroller Defaults to 25.
	    /// If this Store is buffered, pages are loaded into a page cache before the Store's data is updated from the cache. 
	    /// The pageSize is the number of rows loaded into the cache in one request. This will not affect the rendering of a buffered grid, 
	    /// but a larger page size will mean fewer loads. 
	    /// In a buffered grid, scrolling is monitored, and the page cache is kept primed with data ahead of the direction of scroll to provide rapid access to 
	    /// data when scrolling causes it to be required. Several pages in advance may be requested depending on various parameters.
	    /// It is recommended to tune the pageSize, trailingBufferZone and leadingBufferZone configurations based upon the conditions pertaining in your deployed application.
	    /// The provided SDK example examples/grid/infinite-scroll-grid-tuner.html can be used to experiment with different settings including simulating Ajax latency.
	    /// Available since: Ext 4</param>
	    /// <param name="groupField">groupField : String
	    /// The field by which to group data in the store. Internally, grouping is very similar to sorting - the groupField and groupDir are injected as the first sorter (see sort). 
	    /// Stores support a single level of grouping, and groups can be fetched via the getGroups method.
	    /// Available since: Ext 4.1.0</param>
	    /// <param name="data">Object[]/Ext.data.Model[]
	    /// Array of Model instances or data objects to load locally. See "Inline data" above for details.
	    /// Available since: Ext 1</param>
	    IArrayStore CreateArrayStore(

			// Data.AbstractStore
			string storeId = null,
			StoreProxyType? defaultProxyType = null,
			string model = null,
			bool? autoLoad = null,
			IProxy proxy = null,
			[JsConfig]
			IDataField[] fields = null,

			// Data.Store
			bool? remoteSort = null,
			bool? buffered = null,
			int? pageSize = null,
			string groupField = null,
            Array data = null,


			ISorter[] sorters = null
        );

		ISorter Sorter(
			string property,
			SortOrder? direction = null
			);

	    ///  <summary>
	    ///  
	    ///  </summary>
	    ///  
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
	    /// Column
	    /// 
	    /// <param name="text">The header text to be used as innerHTML (html tags are accepted) to display in the Grid. 
	    /// Note: to have a clickable header with no text displayed you can use the default of &#160; aka & nbsp;. Defaults to: '&#160;'</param>
	    /// <param name="sortable">False to disable sorting of this column. Whether local/remote sorting is used is specified in Ext.data.Store.remoteSort. Defaults to true.</param>
	    /// <param name="dataIndex">The name of the field in the grid's Ext.data.Store's Ext.data.Model definition from which to draw the column's value. Required.</param>
	    /// <param name="groupable">If the grid uses a Ext.grid.feature.Grouping, this option may be used to disable the header menu item to group by the column selected. 
	    /// By default, the header menu group option is enabled. Set to false to disable (but still show) the group option in the header menu for the column.</param>
	    /// <param name="renderer">A renderer is an 'interceptor' method which can be used transform data (value, appearance, etc.) before it is rendered.
	    /// Parameters 
	    ///  value : Object		The data value for the current cell
	    ///  metaData : Object	A collection of metadata about the current cell; can be used or modified by the renderer. Recognized properties are: tdCls, tdAttr, and style.
	    ///  record : Ext.data.Model		The record for the current row
	    ///  rowIndex : Number	The index of the current row
	    ///  colIndex : Number	The index of the current column
	    ///  store : Ext.data.Store	The data store
	    ///  view : Ext.view.View	The current view
	    ///  Returns String:  The HTML string to be rendered.
	    ///  </param>
	    /// <param name="xtype">http://docs.sencha.com/ext-js/4-0/#!/api/Ext.grid.column.Column-cfg-xtype</param>
	    /// <param name="tdCls">A CSS class names to apply to the table cells for this column.</param>
	    /// <param name="hideable">False to prevent the user from hiding this column. Defaults to: true</param>
	    /// <param name="editor">Object/String
	    /// An optional xtype or config object for a Field to use for editing. Only applicable if the grid is using an Editing plugin.
	    /// Available since: Ext 3</param>
        /// <param name="align">String
        /// Sets the alignment of the header and rendered columns. Possible values are: 'left', 'center', and 'right'.
        /// Defaults to: 'left'
        /// Available since: Ext 3</param>
        /// 
	    /// <param name="tpl"> String/Ext.XTemplate
	    /// An XTemplate, or an XTemplate definition string to use to process a Model's data to produce a column's rendered value.
	    /// Available since: Ext 3
	    /// Overrides: Ext.AbstractComponent.tpl</param>
	    IColumn Column(
			// Column				
			string dataIndex,
			string text = null,
			bool? sortable = null,
			bool? groupable = null,
			Expression<Func<object, string, object[], int, int, IStore, IView, string>> renderer = null,
            Expression<Func<IModel, object, IFormFieldBase>> getEditor = null,
			string xtype = null,
			string tdCls = null,
			bool? hideable = null,
			//[JsConfig]
            IComponent editor = null,
            ColumnAlign? align = null,
            // this is really for Column.Template
			string tpl = null,

			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string id = null,
			string html = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null
		);

		/// <summary>
		/// A Column definition class which renders boolean data fields. See the xtype config option of Ext.grid.column.Column for more details.
		/// </summary>
		///  
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// Column
		/// 
		/// <param name="text">The header text to be used as innerHTML (html tags are accepted) to display in the Grid. 
		/// Note: to have a clickable header with no text displayed you can use the default of &#160; aka & nbsp;. Defaults to: '&#160;'</param>
		/// Each child item with a flex property will be flexed horizontally according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).</param>
		/// <param name="sortable">False to disable sorting of this column. Whether local/remote sorting is used is specified in Ext.data.Store.remoteSort. Defaults to true.</param>
		/// <param name="dataIndex">The name of the field in the grid's Ext.data.Store's Ext.data.Model definition from which to draw the column's value. Required.</param>
		/// <param name="groupable">If the grid uses a Ext.grid.feature.Grouping, this option may be used to disable the header menu item to group by the column selected. 
		/// By default, the header menu group option is enabled. Set to false to disable (but still show) the group option in the header menu for the column.</param>
		/// <param name="renderer">A renderer is an 'interceptor' method which can be used transform data (value, appearance, etc.) before it is rendered.
		/// Parameters 
		///  value : Object		The data value for the current cell
		///  metaData : Object	A collection of metadata about the current cell; can be used or modified by the renderer. Recognized properties are: tdCls, tdAttr, and style.
		///  record : Ext.data.Model		The record for the current row
		///  rowIndex : Number	The index of the current row
		///  colIndex : Number	The index of the current column
		///  store : Ext.data.Store	The data store
		///  view : Ext.view.View	The current view
		///  Returns String:  The HTML string to be rendered.
		///  </param>
		/// <param name="xtype">http://docs.sencha.com/ext-js/4-0/#!/api/Ext.grid.column.Column-cfg-xtype</param>
		/// <param name="tdCls">A CSS class names to apply to the table cells for this column.</param>
		/// <param name="hideable">False to prevent the user from hiding this column. Defaults to: true</param>
		/// <param name="editor">Object/String
		/// An optional xtype or config object for a Field to use for editing. Only applicable if the grid is using an Editing plugin.
		/// Available since: Ext 3</param>
        /// <param name="align">String
        /// Sets the alignment of the header and rendered columns. Possible values are: 'left', 'center', and 'right'.
        /// Defaults to: 'left'
        /// Available since: Ext 3</param>
        /// 
		/// Column.Boolean
		/// 
		/// <param name="falseText">The string returned by the renderer when the column value is falsey (but not undefined).
		/// Defaults to: 'false'
		/// Available since: Ext 3</param>
		/// <param name="trueText">The string returned by the renderer when the column value is not falsey.
		/// Defaults to: 'true'
		/// Available since: Ext 3</param>
		/// <param name="undefinedText">The string returned by the renderer when the column value is undefined.
		/// Defaults to: '&#160;'
		/// Available since: Ext 3</param>
		/// <returns></returns>
		IBooleanColumn BooleanColumn(
			// Column				
			string dataIndex,
			string text = null,
			bool? sortable = null,
			bool? groupable = null,
			Expression<Func<object, string, object[], int, int, IStore, IView, string>> renderer = null,
			string xtype = null,
			string tdCls = null,
			bool? hideable = null,
			[JsConfig]
            IComponent editor = null,
            ColumnAlign? align = null,

			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// Column.Boolean
			string falseText = null,
			string trueText = null,
			string undefinedText = null
		);

	    /// <summary>
	    /// A Column definition class which renders a passed date according to the default locale, or a configured format.
	    /// </summary>
	    /// 
	    /// Ext.AbstractComponent
	    /// <param name="width">Number
	    /// The width of this component in pixels.
	    /// Available since: Ext 4</param>
	    /// <param name="height">Number
	    /// The height of this component in pixels.
	    /// Available since: Ext 4</param>
	    /// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
	    /// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
	    /// <param name="style">String/Object
	    /// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
	    /// <param name="html">String/Object
	    /// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
	    /// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
	    /// Defaults to: ''
	    /// Available since: Ext 3</param>
	    /// <param name="id">String
	    /// The unique id of this component instance.
	    /// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
	    /// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
	    /// The Container class contains shortcut methods to query its descendant Components by selector.
	    /// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
	    /// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
	    /// Note: To avoid complications imposed by a unique id also see itemId.
	    /// Note: To access the container of a Component see ownerCt.
	    /// Defaults to an auto-assigned id.
	    /// Available since: Ext 1</param>
	    /// <param name="loader">Ext.ComponentLoader/Object
	    /// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
	    /// <param name="flex">Attached property from Ext.layout.container.Box
	    /// Number 
	    /// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
	    /// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
	    /// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
	    /// Available since: Ext 4
	    /// </param>
	    /// <param name="anchor">Attached property from Ext.layout.container.Anchor
	    /// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
	    /// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
	    /// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
	    /// 
	    /// Column
	    /// 
	    /// <param name="text">The header text to be used as innerHTML (html tags are accepted) to display in the Grid. 
	    /// Note: to have a clickable header with no text displayed you can use the default of &#160; aka & nbsp;. Defaults to: '&#160;'</param>
	    /// <param name="sortable">False to disable sorting of this column. Whether local/remote sorting is used is specified in Ext.data.Store.remoteSort. Defaults to true.</param>
	    /// <param name="dataIndex">The name of the field in the grid's Ext.data.Store's Ext.data.Model definition from which to draw the column's value. Required.</param>
	    /// <param name="groupable">If the grid uses a Ext.grid.feature.Grouping, this option may be used to disable the header menu item to group by the column selected. 
	    /// By default, the header menu group option is enabled. Set to false to disable (but still show) the group option in the header menu for the column.</param>
	    /// <param name="renderer">A renderer is an 'interceptor' method which can be used transform data (value, appearance, etc.) before it is rendered.
	    /// Parameters 
	    ///  value : Object		The data value for the current cell
	    ///  metaData : Object	A collection of metadata about the current cell; can be used or modified by the renderer. Recognized properties are: tdCls, tdAttr, and style.
	    ///  record : Ext.data.Model		The record for the current row
	    ///  rowIndex : Number	The index of the current row
	    ///  colIndex : Number	The index of the current column
	    ///  store : Ext.data.Store	The data store
	    ///  view : Ext.view.View	The current view
	    ///  Returns String:  The HTML string to be rendered.
	    ///  </param>
	    /// <param name="xtype">http://docs.sencha.com/ext-js/4-0/#!/api/Ext.grid.column.Column-cfg-xtype</param>
	    /// <param name="tdCls">A CSS class names to apply to the table cells for this column.</param>
	    /// <param name="hideable">False to prevent the user from hiding this column. Defaults to: true</param>
	    /// <param name="editor">Object/String
	    /// An optional xtype or config object for a Field to use for editing. Only applicable if the grid is using an Editing plugin.
	    /// Available since: Ext 3</param>
        /// <param name="align">String
        /// Sets the alignment of the header and rendered columns. Possible values are: 'left', 'center', and 'right'.
        /// Defaults to: 'left'
        /// Available since: Ext 3</param>
        /// 
	    /// Column.Date
	    /// 
	    /// <param name="format">
	    /// A formatting string as used by Ext.Date.format to format a Date for this Column.
	    /// Defaults to the default date from Ext.Date.defaultFormat which itself my be overridden in a locale file.
	    /// Available since: Ext 3</param>		
	    /// <returns></returns>
	    IDateColumn DateColumn(
			// Column				
			string dataIndex,
			string text = null,
			bool? sortable = null,
			bool? groupable = null,
			ColumnRenderer renderer = null,
			string xtype = null,
			string tdCls = null,
			bool? hideable = null,
			[JsConfig]
            IComponent editor = null,
            ColumnAlign? align = null,
 
			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// Column.Date
			string format = null
		);

		/// <summary>A Column definition class which renders a numeric data field according to a format string.</summary>
		/// /// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4 </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// Column
		/// 
		/// <param name="text">The header text to be used as innerHTML (html tags are accepted) to display in the Grid. 
		/// Note: to have a clickable header with no text displayed you can use the default of &#160; aka & nbsp;. Defaults to: '&#160;'</param>
		/// <param name="sortable">False to disable sorting of this column. Whether local/remote sorting is used is specified in Ext.data.Store.remoteSort. Defaults to true.</param>
		/// <param name="dataIndex">The name of the field in the grid's Ext.data.Store's Ext.data.Model definition from which to draw the column's value. Required.</param>
		/// <param name="groupable">If the grid uses a Ext.grid.feature.Grouping, this option may be used to disable the header menu item to group by the column selected. 
		/// By default, the header menu group option is enabled. Set to false to disable (but still show) the group option in the header menu for the column.</param>
		/// <param name="renderer">A renderer is an 'interceptor' method which can be used transform data (value, appearance, etc.) before it is rendered.
		/// Parameters 
		///  value : Object		The data value for the current cell
		///  metaData : Object	A collection of metadata about the current cell; can be used or modified by the renderer. Recognized properties are: tdCls, tdAttr, and style.
		///  record : Ext.data.Model		The record for the current row
		///  rowIndex : Number	The index of the current row
		///  colIndex : Number	The index of the current column
		///  store : Ext.data.Store	The data store
		///  view : Ext.view.View	The current view
		///  Returns String:  The HTML string to be rendered.
		///  </param>
		/// <param name="xtype">http://docs.sencha.com/ext-js/4-0/#!/api/Ext.grid.column.Column-cfg-xtype</param>
		/// <param name="tdCls">A CSS class names to apply to the table cells for this column.</param>
		/// <param name="hideable">False to prevent the user from hiding this column. Defaults to: true</param>
		/// <param name="editor">Object/String
		/// An optional xtype or config object for a Field to use for editing. Only applicable if the grid is using an Editing plugin.
		/// Available since: Ext 3</param>
        /// <param name="align">String
        /// Sets the alignment of the header and rendered columns. Possible values are: 'left', 'center', and 'right'.
        /// Defaults to: 'left'
        /// Available since: Ext 3</param>
        /// 
		/// Column.Number
		/// 
		/// 
		/// <param name="format">A formatting string as used by Ext.util.Format.number to format a numeric value for this Column.
		/// Defaults to: '0,000.00'
		/// Available since: Ext 3</param>
		INumberColumn NumberColumn(
			// Column				
			string dataIndex,
			string text = null,
			bool? sortable = null,
			bool? groupable = null,
			Expression<Func<object, string, object[], int, int, IStore, IView, string>> renderer = null,
			string xtype = null,
			string tdCls = null,
			bool? hideable = null,
			[JsConfig]
            IComponent editor = null,
            ColumnAlign? align = null,

			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// Column.Number
			string format = null
		);

		/// <summary>
		/// A Column definition class which renders a value by processing a Model's data using a configured XTemplate.
		/// </summary>
		/// 
		///  Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4 </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// Column
		/// 
		/// <param name="text">The header text to be used as innerHTML (html tags are accepted) to display in the Grid. 
		/// Note: to have a clickable header with no text displayed you can use the default of &#160; aka & nbsp;. Defaults to: '&#160;'</param>
		/// <param name="sortable">False to disable sorting of this column. Whether local/remote sorting is used is specified in Ext.data.Store.remoteSort. Defaults to true.</param>
		/// <param name="dataIndex">The name of the field in the grid's Ext.data.Store's Ext.data.Model definition from which to draw the column's value. Required.</param>
		/// <param name="groupable">If the grid uses a Ext.grid.feature.Grouping, this option may be used to disable the header menu item to group by the column selected. 
		/// By default, the header menu group option is enabled. Set to false to disable (but still show) the group option in the header menu for the column.</param>
		/// <param name="renderer">A renderer is an 'interceptor' method which can be used transform data (value, appearance, etc.) before it is rendered.
		/// Parameters 
		///  value : Object		The data value for the current cell
		///  metaData : Object	A collection of metadata about the current cell; can be used or modified by the renderer. Recognized properties are: tdCls, tdAttr, and style.
		///  record : Ext.data.Model		The record for the current row
		///  rowIndex : Number	The index of the current row
		///  colIndex : Number	The index of the current column
		///  store : Ext.data.Store	The data store
		///  view : Ext.view.View	The current view
		///  Returns String:  The HTML string to be rendered.
		///  </param>
		/// <param name="xtype">http://docs.sencha.com/ext-js/4-0/#!/api/Ext.grid.column.Column-cfg-xtype</param>
		/// <param name="tdCls">A CSS class names to apply to the table cells for this column.</param>
		/// <param name="hideable">False to prevent the user from hiding this column. Defaults to: true</param>
		/// <param name="editor">Object/String
		/// An optional xtype or config object for a Field to use for editing. Only applicable if the grid is using an Editing plugin.
		/// Available since: Ext 3</param>
        /// <param name="align">String
        /// Sets the alignment of the header and rendered columns. Possible values are: 'left', 'center', and 'right'.
        /// Defaults to: 'left'
        /// Available since: Ext 3</param>
		/// 
		/// Column.Template
		/// 
		/// <param name="tpl"> String/Ext.XTemplate
		/// An XTemplate, or an XTemplate definition string to use to process a Model's data to produce a column's rendered value.
		/// Available since: Ext 3
		/// Overrides: Ext.AbstractComponent.tpl</param>
		/// 
		/// 
		/// <returns></returns>
		ITemplateColumn TemplateColumn(
			// Column				
            string dataIndex = null,
            string text = null,
			bool? sortable = null,
			bool? groupable = null,
			Expression<Func<object, string, object[], int, int, IStore, IView, string>> renderer = null,
			string xtype = null,
			string tdCls = null,
			bool? hideable = null,
			[JsConfig]
            IComponent editor = null,
            ColumnAlign? align = null,

			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// Column.Number
			string tpl = null
		);

        /// <summary>
        /// A config object that will be applied to the grid's UI view. Any of the config options available for Ext.view.Table can be specified here. This option is ignored if view is specified.
        /// Available since: Ext 4
        /// </summary>
        /// <param name="stripeRows">true to stripe the rows. Default is true.
        ///     This causes the CSS class x-grid-row-alt to be added to alternate rows of the grid. 
        ///     A default CSS rule is provided which sets a background color, but you can override this 
        ///     with a rule which either overrides the background-color style using the '!important' modifier, or which uses a CSS selector of higher specificity.
        ///     Defaults to: true</param>
        /// <param name="forceFit">Boolean
        ///     true to force the columns to fit into the available width. Headers are first sized according to configuration, whether that be a specific width, or flex. 
        ///     Then they are all proportionally changed in width so that the entire content width is used. For more accurate control, it is more optimal to specify a 
        ///     flex setting on the columns that are to be stretched & explicit widths on columns that are not.
        ///     Available since: Ext 4</param>
        /// <param name="loadMask"></param>
        /// <param name="getRowClass"></param>
        IViewConfig ViewConfig(
            bool? stripeRows = null,
            bool? forceFit = null,
            bool? loadMask = null,
            string emptyText = null,
            Expression<Func<IModel, int, string>> getRowClass = null);
		/// <summary>
		/// 
		/// </summary>
		/// <param name="store">The Store the grid should use as its data source.</param>
		/// <param name="hideCollapseTool">true to hide the expand/collapse toggle button when collapsible == true, false to display it. Defaults to: false</param>
		/// <param name="columnLines">Adds column line styling. Defaults to: false</param>
		/// <param name="columns">An array of column definition objects which define all columns that appear in this grid. Each column definition provides the header text for the column, 
		/// and a definition of where the data for that column comes from. Available since: Ext 4</param>
		/// <param name="title">The title text to be used to display in the panel header. When a title is specified the Ext.panel.Header will automatically 
		/// be created and displayed unless preventHeader is set to true. Defaults to: ''</param>
		/// <param name="viewConfig">A config object that will be applied to the grid's UI view. Any of the config options available for Ext.view.Table can be specified here. 
		/// This option is ignored if view is specified.</param>
		/// <param name="frame">True to apply a frame to the panel.</param>
		/// <param name="iconCls">CSS class for an icon in the header. Used for displaying an icon to the left of a title.</param>
		/// 
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// Component
		/// 
		/// <param name="region">
		/// "north"/"south"/"east"/"west"/"center"
		/// Defines the region inside border layout.
		/// Possible values:
		/// north - Positions component at top.
		/// south - Positions component at bottom.
		/// east - Positions component at right.
		/// west - Positions component at left.
		/// center - Positions component at the remaining space. 
		/// There must be a component with region: "center" in every border layout.
		/// Available since: Ext 4.1.1</param> 
		/// <param name="autoScroll">Boolean
		/// true to use overflow:'auto' on the components layout element and show scroll bars automatically when necessary, false to clip any overflowing content. 
		/// This should not be combined with overflowX or overflowY.
		/// Defaults to: false</param>
		/// 
		///  Ext.panel.AbstractPanel
		/// 
		///  <param name="baseCls">The base CSS class to apply to this panel's element. Defaults to: x-panel. Available since: Ext 2</param>
		///  <param name="bodyCls">String/String[]. CSS class, space-delimited string of classes, or array of classes to be applied to the panel's body element. 
		///  The following examples are all valid: 
		///  bodyCls: 'foo'    
		///  bodyCls: 'foo bar'  
		///  bodyCls: ['foo', 'bar']</param>
		///  <param name="bodyPadding">A shortcut for setting a padding style on the body element. The value can either be a number to be applied to all sides, 
		///  or a normal css string describing padding. Defaults to undefined.</param>
		/// <param name="bodyStyle">String/Object/Function2
		/// Custom CSS styles to be applied to the panel's body element, which can be supplied as a valid CSS style string, an object containing style property name/value pairs or 
		/// a function that returns such a string or object.</param>
		/// <param name="border">Number/String/Boolean2
		/// Specifies the border size for this component. 
		/// The border can be a single numeric value to apply to all sides or it can be a CSS style specification for each style, for example: '10 5 3 10' (top, right, bottom, left).
		/// For components that have no border by default, setting this won't make the border appear by itself. You also need to specify border color and style</param>
		/// 
		/// Panel
		/// 
		/// <param name="bbar">Convenience config. Short for 'Bottom Bar'.
		/// Available since: Ext 2</param>
		/// 
		/// panel.Table
		/// 
		/// <param name="features">Ext.grid.feature.Feature[]/Object[]/Ext.enums.Feature[]
		/// An array of grid Features to be added to this grid. Can also be just a single feature instead of array.
		/// Features config behaves much like plugins. A feature can be added by either directly referencing the instance:
		/// features: [Ext.create('Ext.grid.feature.GroupingSummary', {groupHeaderTpl: 'Subject: {name}'})],
		/// By using config object with ftype: features: [{ftype: 'groupingsummary', groupHeaderTpl: 'Subject: {name}'}],
		/// Or with just a ftype: features: ['grouping', 'groupingsummary'],
		/// See Ext.enums.Feature for list of all ftypes.
		/// Available since: Ext 4</param>
		/// <param name="plugins"> Ext.AbstractPlugin[]/Object[]/Ext.enums.Plugin[]
		/// An array of plugins to be added to this component. Can also be just a single plugin instead of array.
		/// Plugins provide custom functionality for a component. The only requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component. 
		/// When a component is created, if any plugins are available, the component will call the init method on each plugin, passing a reference to itself. Each plugin can 
		/// then call methods or respond to events on the component as needed to provide its functionality.
		/// Plugins can be added to component by either directly referencing the plugin instance:
		/// plugins: [Ext.create('Ext.grid.plugin.CellEditing', {clicksToEdit: 1})],
		/// By using config object with ptype:
		/// plugins: [{ptype: 'cellediting', clicksToEdit: 1}],
		/// Or with just a ptype:
		/// plugins: ['cellediting', 'gridviewdragdrop'],
		/// See Ext.enums.Plugin for list of all ptypes.
		/// Available since: Ext 2</param>
		/// <param name="selModel">Ext.selection.Model/Object
		/// A selection model instance or config object. In latter case the selType config option determines to which type of selection model this config is applied.
		/// Available since: Ext 4</param>
		///  
		/// <returns></returns>
		IGridPanel CreateGridPanel(
            // Ext.panel.AbstractPanel
            string baseCls = null,
            string bodyCls = null,
            Padding bodyPadding = null,
            string bodyStyle = null,
            Border border = null,

            // Ext.panel.Panel
            IToolbar bbar = null,
            IToolbar tbar = null,

			// Ext.panel.Table
			IGridFeature[] features = null, 
			IPlugin[] plugins = null,
            ISelectionModel selModel = null,

			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,
            int? minHeight = null,
            int? maxHeight = null,
            bool? split = null,

			// component
			Region? region = null,
			bool? autoScroll = null,

			IStore store = null,
			bool? hideCollapseTool = null,
			bool? columnLines = null,
			[JsConfig]
			IColumn[] columns = null,
			string title = null,
			[JsConfig]
			IViewConfig viewConfig = null,
			bool? frame = null,
			string iconCls = null,
			IBase renderTo = null,
			IBase[] dockedItems = null

		);

		IPropertyGrid CreatePropertyGrid(
			bool? autoScroll = null,
			bool? autoWidth = null,
			bool? autoHeight = null,
			IStore store = null,
			[JsConfig]
			IViewConfig viewConfig = null,
			Border border = null
		);

		/// <summary>
		/// Represents Ext.menu.Menu
		/// </summary>
		/// <param name="id">The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: to avoid complications imposed by a unique id also see itemId.
		/// Note: to access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.</param>
		/// <param name="border">Specifies the border for this component. The border can be a single numeric value to apply to all sides or it can be a CSS style specification for each style, 
		/// for example: '10 5 3 10'.Defaults to: true</param>
		///  
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// Component
		/// 
		/// <param name="region">
		/// "north"/"south"/"east"/"west"/"center"
		/// Defines the region inside border layout.
		/// Possible values:
		/// north - Positions component at top.
		/// south - Positions component at bottom.
		/// east - Positions component at right.
		/// west - Positions component at left.
		/// center - Positions component at the remaining space. 
		/// There must be a component with region: "center" in every border layout.
		/// Available since: Ext 4.1.1</param> 
		/// 
		/// 
		/// <param name="collapsed">true to render the panel collapsed, false to render it expanded. Defaults to: false</param>
		/// <param name="title">The title text to be used to display in the panel header. When a title is specified the Ext.panel.Header will automatically be created and displayed unless preventHeader is set to true.
		/// Defaults to: ''</param>
		/// <param name="items">A single item, or an array of child Components to be added to this container
		/// Unless configured with a layout, a Container simply renders child Components serially into its encapsulating element and performs no sizing or positioning upon them.</param>
		/// <returns></returns>
		IMenu CreateMenu(
			// Ext.AbstractComponent
            int? width = null,
            int? height = null,
			string cls = null, 
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// Ext.Component
			Region? region = null,

			bool? border = null,
			bool? collapsed = null,
			string title = null,
			IBase[] items = null
		);

		/// <summary>
		/// A base class for all menu items that require menu-related functionality such as click handling, sub-menus, icons, etc.
		/// </summary>
		/// <param name="id">The unique id of this component instance. It should not be necessary to use this configuration except for singleton objects in your application. 
		/// Components created with an id may be accessed globally using Ext.getCmp. Instead of using assigned ids, use the itemId config, and ComponentQuery which provides 
		/// selector-based searching for Sencha Components analogous to DOM querying. The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: to avoid complications imposed by a unique id also see itemId.
		/// Note: to access the container of a Component see ownerCt. Defaults to an auto-assigned id.</param>
		/// <param name="text">The text/html to display in this item. Defaults to undefined.</param>
		/// <param name="icone">The path to an icon to display in this item. Defaults to Ext.BLANK_IMAGE_URL.</param>
		/// <param name="disabled">Ext.AbstractComponent.disabled 
		/// true to disable the component. Defaults to: false</param>
		/// <param name="menu">Either an instance of Ext.menu.Menu or a config object for an Ext.menu.Menu which will act as a sub-menu to this item.</param>
		/// <returns></returns>
		IMenuItem MenuItem(
			string id = null,
			string text = null,
			IIcone icone = null,
			string url = null,
			bool? disabled = null,
			IMenu menu = null,
			Expression<MenuItemHandler> handler = null
		);

		IToolbar CreateToolbar(
			Region? region = null,	
			int? height = null,
			Margin margins = null,
			IBase[] items = null
		);

		/// <summary>
		/// Ext.form.Label
		/// Produces a standalone <label /> element which can be inserted into a form and be associated with a field in that form using the forId property.
		/// NOTE: in most cases it will be more appropriate to use the fieldLabel and associated config properties (Ext.form.Labelable.labelAlign, Ext.form.Labelable.labelWidth, etc.) 
		/// in field components themselves, as that allows labels to be uniformly sized throughout the form. Ext.form.Label should only be used when your layout can not be achieved with 
		/// the standard field layout.
		/// You will likely be associating the label with a field component that extends Ext.form.field.Base, so you should make sure the forId is set to the same value as the inputId of that field.
		/// The label's text can be set using either the text or html configuration properties; the difference between the two is that the former 
		/// will automatically escape HTML characters when rendering, while the latter will not.
		/// </summary>
		/// 
		///  Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// <returns></returns>
		ILabel CreateLabel(
			// Ext.AbstractComponent
            int? width = null,
            int? height = null,
			string cls = null, 
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null
		);

		IToolbarFill CreateToolbarFill();

		IToolbarText CreateToolbarText(
			string text = null
		);

		/// <summary>
		/// 
		/// </summary>
		/// 
		///  Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// button.Button
		/// 
		/// <param name="text">String
		/// The button text to be used as innerHTML (html tags are accepted).
		/// Available since: Ext 1</param>
		/// <param name="menu">Ext.menu.Menu/String/Object
		/// Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob.
		/// Available since: Ext 1</param>
		/// <param name="handler">Function
		/// A function called when the button is clicked (can be used instead of click event).
		/// Available since: Ext 1</param>
		/// <returns></returns>
		IButton CreateButton(
			// Ext.AbstractComponent
            int? width = null,
            int? height = null,
			string cls = null, 
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// button
			string text = null,
			IMenu menu = null,
			Expression<ButtonHandler> handler = null,
            string tooltip = null,
            string overflowText = null,
            string iconCls = null
		);

		/// <summary>
		/// A basic tab container. TabPanels can be used exactly like a standard Ext.panel.Panel for layout purposes, but also have special support for containing child Components (items) that 
		/// are managed using a CardLayout layout manager, and displayed as separate tabs.
		/// Note: By default, a tab's close tool destroys the child tab Component and all its descendants. This makes the child tab Component, and all its descendants unusable. 
		/// To enable re-use of a tab, configure the TabPanel with autoDestroy: false.
		/// TabPanel's layout
		/// TabPanels use a Dock layout to position the TabBar at the top of the widget. Panels added to the TabPanel will have their header hidden by default because 
		/// the Tab will automatically take the Panel's configured title and icon.	TabPanels use their header or footer element (depending on the tabPosition configuration) 
		/// to accommodate the tab selector buttons. This means that a TabPanel will not display any configured title, and will not display any configured header tools.
		/// To display a header, embed the TabPanel in a Panel which uses layout: 'fit'.
		/// </summary>
		/// 
		///  Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		///  Ext.panel.AbstractPanel
		/// 
		///  <param name="baseCls">The base CSS class to apply to this panel's element. Defaults to: x-panel. Available since: Ext 2</param>
		///  <param name="bodyCls">String/String[]. CSS class, space-delimited string of classes, or array of classes to be applied to the panel's body element. 
		///  The following examples are all valid: 
		///  bodyCls: 'foo'    
		///  bodyCls: 'foo bar'  
		///  bodyCls: ['foo', 'bar']</param>
		///  <param name="bodyPadding">A shortcut for setting a padding style on the body element. The value can either be a number to be applied to all sides, 
		///  or a normal css string describing padding. Defaults to undefined.</param>
		/// <param name="bodyStyle">String/Object/Function2
		/// Custom CSS styles to be applied to the panel's body element, which can be supplied as a valid CSS style string, an object containing style property name/value pairs or 
		/// a function that returns such a string or object.</param>
		/// <param name="border">Number/String/Boolean2
		/// Specifies the border size for this component. 
		/// The border can be a single numeric value to apply to all sides or it can be a CSS style specification for each style, for example: '10 5 3 10' (top, right, bottom, left).
		/// For components that have no border by default, setting this won't make the border appear by itself. You also need to specify border color and style</param>
		/// 
		/// AbstractContainer
		/// 
		/// <param name="items">Object/Object[]
		/// A single item, or an array of child Components to be added to this container
		/// Unless configured with a layout, a Container simply renders child Components serially into its encapsulating element and performs no sizing or positioning upon them.</param>
		/// <param name="layout"> Ext.enums.Layout/Object
		/// Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specified through the layout configuration option.
		/// The sizing and positioning of child items is the responsibility of the Container's layout manager which creates and manages the type of layout you have in mind. For example:
		/// If the layout configuration is not explicitly specified for a general purpose container (e.g. Container or Panel) the default layout manager will be used which does nothing 
		/// but render child components sequentially into the Container (no sizing or positioning will be performed in this situation).</param>
		/// 
		/// 
		/// Component
		/// 
		/// <param name="region">
		/// "north"/"south"/"east"/"west"/"center"
		/// Defines the region inside border layout.
		/// Possible values:
		/// north - Positions component at top.
		/// south - Positions component at bottom.
		/// east - Positions component at right.
		/// west - Positions component at left.
		/// center - Positions component at the remaining space. 
		/// There must be a component with region: "center" in every border layout.
		/// Available since: Ext 4.1.1</param> 
		/// 
		/// panel.Panel
		/// 
		/// <param name="collapsible">True to make the panel collapsible and have an expand/collapse toggle Tool added into the header tool button area. 
		/// False to keep the panel sized either statically, or by an owning layout manager, with no toggle Tool. When a panel is used in a border layout, 
		/// the floatable option can influence the behavior of collapsing. See collapseMode and collapseDirection</param>
		/// <param name="animCollapse">true to animate the transition when the panel is collapsed, false to skip the animation 
		/// (defaults to true if the Ext.fx.Anim class is available, otherwise false). May also be specified as the animation duration in milliseconds.</param>
		/// 
		/// Tab.Panel
		/// 
		/// <param name="plain">Boolean
		/// True to not show the full background on the TabBar.
		/// Defaults to: false
		/// Available since: Ext 2</param>
		/// <returns></returns>
		ITabPanel CreateTabPanel(
			// Ext.panel.AbstractPanel
			string baseCls = null,
			string bodyCls = null,
			Padding bodyPadding = null,
			string bodyStyle = null,
			Border border = null,

			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,


			// AbstractContainer
			[JsConfig]
            ILayout layout = null,
			// AbstractContainer
			IComponent[] items = null,

			// Component
			Region? region = null,

			// panel.panel 
			bool? collapsible = null,
			bool? animCollapse = null,

			// tab.panel
			bool? plain = null,
			String title = null,
			bool? split = null,
			int? minHeight = null

		);

		/// <summary>
		/// Represents a single Tab in a TabPanel. A Tab is simply a slightly customized Button, styled to look like a tab. Tabs are optionally closable, and can also be disabled. 
		/// 99% of the time you will not need to create Tabs manually as the framework does so automatically when you use a TabPanel
		/// </summary>
		/// 
		///  Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// button.Button
		/// 
		/// <param name="text">String
		/// The button text to be used as innerHTML (html tags are accepted).
		/// Available since: Ext 1</param>
		/// <param name="menu">Ext.menu.Menu/String/Object
		/// Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob.
		/// Available since: Ext 1</param>
		/// <returns></returns>
		/// 
		/// Tab
		/// 
		/// <param name="activeCls">String
		/// The CSS class to be applied to a Tab when it is active. Providing your own CSS for this class enables you to customize the active state.
		/// Defaults to: 'active'
		/// Available since: Ext 4</param>
		/// <param name="baseCls">String
		/// The base CSS class to add to all buttons.
		/// Defaults to: Ext.baseCSSPrefix + 'tab'
		/// Available since: Ext 4
		/// Overrides: Ext.button.Button.baseCls</param>
		/// <param name="closable">Boolean
		/// True to make the Tab start closable (the close icon will be visible).
		/// Defaults to: true
		/// Available since: Ext 4</param>
		/// <param name="closableCls">String
		/// The CSS class which is added to the tab when it is closable
		/// Defaults to: 'closable'
		/// Available since: Ext 4</param>
		/// <param name="closeText">String
		/// The accessible text label for the close button link; only used when closable = true.
		/// Defaults to: 'Close Tab'
		/// Available since: Ext 4</param>
		/// <param name="componentLayout">String/Object
		/// The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager which sizes a Component's internal structure 
		/// in response to the Component being sized.
		/// Generally, developers will not use this configuration as all provided Components which need their internal elements sizing (Such as input fields) come with their own componentLayout managers.
		/// The default layout manager will be used on instances of the base Ext.Component class which simply sizes the Component's encapsulating element to the height and width 
		/// specified in the setSize method.
		/// Defaults to: 'tab'
		/// Available since: Ext 4
		/// Overrides: Ext.button.Button.componentLayout</param>
		/// <param name="disabledCls">String
		/// The CSS class to be applied to a Tab when it is disabled.
		/// Defaults to: 'x-tab-disabled'
		/// Available since: Ext 4
		/// Overrides: Ext.AbstractComponent.disabledCls</param>
		/// <returns></returns>
		ITab CreateTab(
			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,


			// tab
			string activeCls = null,
			string baseCls = null,
			bool? closable = null,
			string closableCls = null,
			string closeText = null,
			string componentLayout = null,
			string disabledCls = null,

			// button
			string text = null,
			IMenu menu = null 
		);

		/// <summary>
		/// because of error: 'expr tree cannot contain a call or invocation that uses optional arguments' we introduced this method for callbacks
		/// </summary>
		/// <returns></returns>
		ITab CreateNewTab(string title, [JsConfig] IComponentLoader loader);


	    /// <summary>
	    /// 
	    /// </summary>
	    /// 
	    /// ComponentLoader
	    /// <param name="url">Stringrequired
	    ///     The url to retrieve the content from.
	    ///     Available since: Ext 4</param>
	    /// <param name="autoLoad">True to have the loader make a request as soon as it is created. This argument can also be a set of options that will be passed to load is called. 
	    ///     Defaults to: false</param>
	    /// <param name="loadMask">Boolean/Object
	    ///     True or a Ext.LoadMask configuration to enable masking during loading.
	    ///     Defaults to: false
	    ///     Available since: Ext 4
	    ///     Overrides: Ext.ElementLoader.loadMask</param>
	    /// <param name="b"></param>
	    /// <returns></returns>
	    IComponentLoader Loader(string url, bool autoLoad, bool loadMask, bool scripts);

		///  <summary>
		///  
		///  </summary>
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// Component
		/// 
		/// <param name="region">
		/// "north"/"south"/"east"/"west"/"center"
		/// Defines the region inside border layout.
		/// Possible values:
		/// north - Positions component at top.
		/// south - Positions component at bottom.
		/// east - Positions component at right.
		/// west - Positions component at left.
		/// center - Positions component at the remaining space. 
		/// There must be a component with region: "center" in every border layout.
		/// Available since: Ext 4.1.1</param> 
		/// 
		///  Ext.panel.AbstractPanel
		/// 
		///  <param name="baseCls">The base CSS class to apply to this panel's element. Defaults to: x-panel. Available since: Ext 2</param>
		///  <param name="bodyCls">String/String[]. CSS class, space-delimited string of classes, or array of classes to be applied to the panel's body element. 
		///  The following examples are all valid: 
		///  bodyCls: 'foo'    
		///  bodyCls: 'foo bar'  
		///  bodyCls: ['foo', 'bar']</param>
		///  <param name="bodyPadding">A shortcut for setting a padding style on the body element. The value can either be a number to be applied to all sides, 
		///  or a normal css string describing padding. Defaults to undefined.</param>
		/// <param name="bodyStyle">String/Object/Function2
		/// Custom CSS styles to be applied to the panel's body element, which can be supplied as a valid CSS style string, an object containing style property name/value pairs or 
		/// a function that returns such a string or object.</param>
		/// <param name="border">Number/String/Boolean2
		/// Specifies the border size for this component. 
		/// The border can be a single numeric value to apply to all sides or it can be a CSS style specification for each style, for example: '10 5 3 10' (top, right, bottom, left).
		/// For components that have no border by default, setting this won't make the border appear by itself. You also need to specify border color and style</param>
		/// 
		/// panel.Panel
		/// 
		/// <param name="collapsible">True to make the panel collapsible and have an expand/collapse toggle Tool added into the header tool button area. 
		/// False to keep the panel sized either statically, or by an owning layout manager, with no toggle Tool. When a panel is used in a border layout, 
		/// the floatable option can influence the behavior of collapsing. See collapseMode and collapseDirection</param>
		/// <param name="animCollapse">true to animate the transition when the panel is collapsed, false to skip the animation 
		/// (defaults to true if the Ext.fx.Anim class is available, otherwise false). May also be specified as the animation duration in milliseconds.</param>
		/// <param name="buttons">Object/Object[]
		/// Convenience config used for adding buttons docked to the bottom of the panel. This is a synonym for the fbar config.</param>
		/// 
		/// 
		/// form.Panel
		/// 
		/// <param name="url">Not sure which mixin has. The form will submit an AJAX request to this URL when submitted</param>
		/// /// <returns></returns>
		IFormPanel CreateFormPanel(

			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,


            // Ext.panel.AbstractPanel
            string baseCls = null,
            string bodyCls = null,
            Padding bodyPadding = null,
            string bodyStyle = null,
            Border border = null,

			// ext.Component
            Region? region = null,

			// panel.panel 
			bool? collapsible = null,
			bool? animCollapse = null,
			IComponent[] buttons = null,

			// form.Panel
			string url = null,

            bool? plain = null, 
			[JsConfig]
			ILabelable fieldDefaults = null,
			IContainerLayout layout = null,
			IBase[] items = null,
            bool? frame = null,
            string title = null,
            string padding = null,
            bool? standardSubmit = null);

		///  <summary>
		///  A mixin which allows a component to be configured and decorated with a label and/or error message as is common for form fields. 
		///  This is used by e.g. Ext.form.field.Base and Ext.form.FieldContainer to let them be managed by the Field layout.
		///  </summary>
		///  <param name="labelWidth">Number
		///  The width of the fieldLabel in pixels. Only applicable if the labelAlign is set to "left" or "right".
		///  Defaults to: 100
		///  Available since: Ext 4</param>
		///  <param name="anchor"></param>
		///  <param name="labelAlign">String
		///  Controls the position and alignment of the fieldLabel. Valid values are:
		/// 		"left" (the default) - The label is positioned to the left of the field, with its text aligned to the left. Its width is determined by the labelWidth config.
		/// 		"top" - The label is positioned above the field.
		/// 		"right" - The label is positioned to the left of the field, with its text aligned to the right. Its width is determined by the labelWidth config.
		///  Defaults to: 'left'
		///  Available since: Ext 4</param>
		/// <param name="msgTarget">String
		/// The location where the error message text should display. Must be one of the following values:
		///		qtip	Display a quick tip containing the message when the user hovers over the field. This is the default.
		///				Ext.tip.QuickTipManager.init must have been called for this setting to work.
		///		title	Display the message in a default browser title attribute popup.
		///		under	Add a block div beneath the field containing the error message.
		///		side	Add an error icon to the right of the field, displaying the message in a popup on hover.
		///		none	Don't display any error message. This might be useful if you are implementing custom error display.
		/// [element id] Add the error message directly to the innerHTML of the specified element.
		/// Defaults to: 'qtip'
		/// Available since: Ext 4</param>
		/// <returns></returns>
		ILabelable Labelable(
			int? labelWidth = null, 
			string anchor = null,
			LabelAlign? labelAlign = null,
			LabelTarget? msgTarget = null
		);

		IContainerLayout ContainerLayout(string type, string align);

	    ///  <summary>
	    ///  
	    ///  </summary>
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		/// form.Labelable
		/// 
		/// <param name="fieldLabel">The label for the field. It gets appended with the labelSeparator, and its position and sizing is determined by the labelAlign, labelWidth, and labelPad configs.</param>
		/// <param name="hideLabel">Set to true to completely hide the label element (fieldLabel and labelSeparator). Also see hideEmptyLabel, which controls whether space 
		/// will be reserved for an empty fieldLabel.</param>
		///  
        /// Ext.form.field.Text
        /// 
        /// <param name="emptyText">String
        /// The default text to place into an empty field.
        /// Note that normally this value will be submitted to the server if this field is enabled; to prevent this you can set the submitEmptyText option of Ext.form.Basic.submit to false.
        /// Also note that if you use inputType:'file', emptyText is not supported and should be avoided.
        /// Note that for browsers that support it, setting this property will use the HTML 5 placeholder attribute, and for older browsers that don't support the HTML 5 placeholder attribute 
        /// the value will be placed directly into the input element itself as the raw value. This means that older browsers will obfuscate the emptyText value for password input fields.
        /// Available since: Ext 1</param>
        /// <param name="allowBlank">Boolean
        /// Specify false to validate that the value's length is > 0
        /// Defaults to: true
        /// Available since: Ext 1</param>
        /// 
        /// 
	    /// form.field.Trigger
	    /// <param name="hideTrigger">Boolean
	    /// true to hide the trigger element and display only the base text field
	    /// Defaults to: false
	    /// Available since: Ext 1</param>
	    /// 
	    ///  <param name="displayField">The underlying data field name to bind to this ComboBox. See also valueField. Defaults to: 'text'</param>
	    ///  <param name="valueField">String
	    ///  The underlying data value name to bind to this ComboBox.
	    ///  Note: use of a valueField requires the user to make a selection in order for a value to be mapped. See also displayField.
	    ///  Defaults to match the value of the displayField config.
	    ///  Available since: Ext 1</param>
	    ///  <param name="queryMode">The mode in which the ComboBox uses the configured Store.</param>
	    ///  <param name="selectOnTab">Whether the Tab key should select the currently highlighted item.Defaults to: true</param>
	    ///  <param name="name">The name of the field. This is used as the parameter name when including the field value in a form submit(). If no name is configured, 
	    ///  it falls back to the inputId. To prevent the field from being included in the form submit, set submitValue to false.</param>
	    ///  <param name="typeAhead">Boolean
	    ///  true to populate and autoselect the remainder of the text being typed after a configurable delay (typeAheadDelay) if it matches a known value.
	    ///  Defaults to: false
	    ///  Available since: Ext 1</param>
	    ///  <param name="labelCls">String
	    ///  The CSS class to be applied to the label element. This (single) CSS class is used to formulate the renderSelector and drives the field layout where it is concatenated 
	    ///  with a hyphen ('-') and labelAlign. To add additional classes, use labelClsExtra.
	    ///  Defaults to: Ext.baseCSSPrefix + 'form-item-label' 
	    ///  Available since: Ext 4</param>
	    ///  <param name="pageSize">Number
	    ///  If greater than 0, a Ext.toolbar.Paging is displayed in the footer of the dropdown list and the filter queries will execute with page start and limit parameters. 
	    ///  Only applies when queryMode = 'remote'.
	    ///  Defaults to: 0
	    ///  Available since: Ext 1</param>
	    ///  <param name="minChars">Number
	    ///  The minimum number of characters the user must type before autocomplete and typeAhead activate.
	    ///  Defaults to 4 if queryMode = 'remote' or 0 if queryMode = 'local', does not apply if editable = false.
	    ///  Available since: Ext 1</param>
	    ///  <param name="listConfig">Object
	    ///  An optional set of configuration properties that will be passed to the Ext.view.BoundList's constructor. Any configuration that is valid for BoundList can be included. 
	    ///  Some of the more useful ones are:
	    /// 		cls - defaults to empty
	    /// 		emptyText - defaults to empty string
	    /// 		itemSelector - defaults to the value defined in BoundList
	    /// 		loadingText - defaults to 'Loading...'
	    /// 		minWidth - defaults to 70
	    /// 		maxWidth - defaults to undefined
	    /// 		maxHeight - defaults to 300
	    /// 		resizable - defaults to false
	    /// 		shadow - defaults to 'sides'
	    /// 		width - defaults to undefined (automatically set to the width of the ComboBox field if matchFieldWidth is true)
	    /// Available since: Ext 4</param>
	    /// 
	    /// <returns></returns>
	    IComboBox CreateCombo(
			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			//Ext.form.field.Text
			string emptyText = null,
            bool? allowBlank = null,

            //Ext.form.field.Trigger
			bool? hideTrigger = null,


			// form.Labelable
			string fieldLabel = null,
			bool? hideLabel = null,

			// field.Base
			string name = null,
			string value = null,

			IStore store = null,
 			string displayField = null,
			string valueField = null,
			ComboBoxQueryMode? queryMode = null,
			bool? selectOnTab = null,
			bool? typeAhead = null,
			string labelCls = null,
			int? pageSize = null,
			int? minChars = null,
            [JsConfig]
			IBoundList listConfig = null,
			bool? editable = null,
			bool? forceSelection = null
		);

	    /// <summary>
	    /// 
	    /// </summary>
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		///  field.Base
		/// 
		/// <param name="name">name : String
		/// The name of the field. This is used as the parameter name when including the field value in a form submit(). If no name is configured, it falls back to the inputId. 
		/// To prevent the field from being included in the form submit, set submitValue to false.
		/// Available since: Ext 1
		/// Overrides: Ext.form.field.Field.name</param>
		///  
        /// Ext.form.field.Text
        /// 
        /// <param name="emptyText">String
        /// The default text to place into an empty field.
        /// Note that normally this value will be submitted to the server if this field is enabled; to prevent this you can set the submitEmptyText option of Ext.form.Basic.submit to false.
        /// Also note that if you use inputType:'file', emptyText is not supported and should be avoided.
        /// Note that for browsers that support it, setting this property will use the HTML 5 placeholder attribute, and for older browsers that don't support the HTML 5 placeholder attribute 
        /// the value will be placed directly into the input element itself as the raw value. This means that older browsers will obfuscate the emptyText value for password input fields.
        /// Available since: Ext 1</param>
        /// <param name="allowBlank">Boolean
        /// Specify false to validate that the value's length is > 0
        /// Defaults to: true
        /// Available since: Ext 1</param>
        /// 
		/// form.Labelable
		/// 
        /// <param name="fieldLabel">The label for the field. It gets appended with the labelSeparator, and its position and sizing is determined by the labelAlign, labelWidth, and labelPad configs.</param>
        /// <param name="hideLabel">Set to true to completely hide the label element (fieldLabel and labelSeparator). Also see hideEmptyLabel, which controls whether space 
        /// will be reserved for an empty fieldLabel.</param>
        /// 
        ///  <returns></returns>
	    ITextField CreateTextField(
            // Ext.AbstractComponent
            int? width = null,
            int? height = null,
            string cls = null,
            string style = null,
            string html = null,
            string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// field.Base
			string name = null,

			// form.Labelable
			string fieldLabel = null,
			bool? hideLabel = null,

            //Ext.form.field.Text
            string emptyText = null,
            bool? allowBlank = null,
            
			string value = null
		);

		///  <summary>
		///  
		///  </summary>
		///  
		///  Ext.AbstractComponent
		///  
		///  <param name="width">Number
		///  The width of this component in pixels.
		///  Available since: Ext 4</param>
		///  <param name="height">Number
		///  The height of this component in pixels.
		///  Available since: Ext 4</param>
		///  <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		///  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		///  <param name="style">String/Object
		///  A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		///  <param name="html">String/Object
		///  An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		///  so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		///  Defaults to: ''
		///  Available since: Ext 3</param>
		///  <param name="id">String
		///  The unique id of this component instance.
		///  It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		///  Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		///  The Container class contains shortcut methods to query its descendant Components by selector.
		///  Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		///  This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		///  Note: To avoid complications imposed by a unique id also see itemId.
		///  Note: To access the container of a Component see ownerCt.
		///  Defaults to an auto-assigned id.
		///  Available since: Ext 1</param>
		///  <param name="loader">Ext.ComponentLoader/Object
		///  A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		///  <param name="flex">Attached property from Ext.layout.container.Box
		///  Number 
		///  This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		///  (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		///  Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		///  Available since: Ext 4
		///  </param>
		///  <param name="anchor">Attached property from Ext.layout.container.Anchor
		///  This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		///  This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		///  a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		///  field.Base
		/// 
		/// <param name="name">name : String
		/// The name of the field. This is used as the parameter name when including the field value in a form submit(). If no name is configured, it falls back to the inputId. 
		/// To prevent the field from being included in the form submit, set submitValue to false.
		/// Available since: Ext 1
		/// Overrides: Ext.form.field.Field.name</param>
		/// <param name="value">Object
		/// A value to initialize this field with.Available since: Ext 4</param>
		/// 
		/// 
		/// form.Labelable
		/// <param name="fieldLabel">The label for the field. It gets appended with the labelSeparator, and its position and sizing is determined by the labelAlign, labelWidth, and labelPad configs.</param>
		/// <param name="hideLabel">Set to true to completely hide the label element (fieldLabel and labelSeparator). Also see hideEmptyLabel, which controls whether space 
		/// will be reserved for an empty fieldLabel.</param>
		/// 
		/// field.checkbox
		/// 
		/// <param name="boxLabel">String
		/// An optional text label that will appear next to the checkbox. Whether it appears before or after the checkbox is determined by the boxLabelAlign config.
		/// Available since: Ext 1</param>
		/// <param name="checked">Boolean
		/// true if the checkbox should render initially checked
		/// Defaults to: false</param>
		/// 
		/// <returns></returns>
		ICheckboxField CreateCheckbox(
            // Ext.AbstractComponent
            int? width = null,
            int? height = null,
            string cls = null,
            string style = null,
            string html = null,
            string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// field.Base
			string name = null,
			bool? value = null,


			// form.Labelable
			string fieldLabel = null,
			bool? hideLabel = null,

			// field.checkbox
			bool? @checked = null,
			string boxLabel = null,
            BoxLabelAlign? boxLabelAlign = null
		);

		/// <summary>
		/// 
		/// </summary>
		///  Ext.AbstractComponent
		///  
		///  <param name="width">Number
		///  The width of this component in pixels.
		///  Available since: Ext 4</param>
		///  <param name="height">Number
		///  The height of this component in pixels.
		///  Available since: Ext 4</param>
		///  <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		///  This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		///  <param name="style">String/Object
		///  A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		///  <param name="html">String/Object
		///  An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		///  so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		///  Defaults to: ''
		///  Available since: Ext 3</param>
		///  <param name="id">String
		///  The unique id of this component instance.
		///  It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		///  Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		///  The Container class contains shortcut methods to query its descendant Components by selector.
		///  Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		///  This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		///  Note: To avoid complications imposed by a unique id also see itemId.
		///  Note: To access the container of a Component see ownerCt.
		///  Defaults to an auto-assigned id.
		///  Available since: Ext 1</param>
		///  <param name="loader">Ext.ComponentLoader/Object
		///  A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		///  <param name="flex">Attached property from Ext.layout.container.Box
		///  Number 
		///  This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		///  (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		///  Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		///  Available since: Ext 4
		///  </param>
		///  <param name="anchor">Attached property from Ext.layout.container.Anchor
		///  This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		///  This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		///  a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		///  field.Base
		/// 
		/// <param name="name">name : String
		/// The name of the field. This is used as the parameter name when including the field value in a form submit(). If no name is configured, it falls back to the inputId. 
		/// To prevent the field from being included in the form submit, set submitValue to false.
		/// Available since: Ext 1
		/// Overrides: Ext.form.field.Field.name</param>
		/// <param name="value">Object
		/// A value to initialize this field with.Available since: Ext 4</param>
		/// 
		/// 
		/// form.Labelable
		/// <param name="fieldLabel">The label for the field. It gets appended with the labelSeparator, and its position and sizing is determined by the labelAlign, labelWidth, and labelPad configs.</param>
		/// <param name="hideLabel">Set to true to completely hide the label element (fieldLabel and labelSeparator). Also see hideEmptyLabel, which controls whether space 
		/// will be reserved for an empty fieldLabel.</param>
		/// 
		/// <returns></returns>
		IDateField CreateDateField(
			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// field.Base
			string name = null,
			string value = null,

			// form.Labelable
			string fieldLabel = null,
			bool? hideLabel = null
			
		);


		IHiddenField CreateHidden(
			// field.Base
			string name = null,
			string value = null);
		
		/// <summary>
		/// 
		/// </summary>
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4</param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
		///   field.Base
		/// 
		/// <param name="name">name : String
		/// The name of the field. This is used as the parameter name when including the field value in a form submit(). If no name is configured, it falls back to the inputId. 
		/// To prevent the field from being included in the form submit, set submitValue to false.
		/// Available since: Ext 1
		/// Overrides: Ext.form.field.Field.name</param>
		/// 
		/// 
		/// form.Labelable
		/// 
		/// <param name="fieldLabel">The label for the field. It gets appended with the labelSeparator, and its position and sizing is determined by the labelAlign, labelWidth, and labelPad configs.</param>
		/// <param name="hideLabel">Set to true to completely hide the label element (fieldLabel and labelSeparator). Also see hideEmptyLabel, which controls whether space 
		/// will be reserved for an empty fieldLabel.</param>
		/// 
		/// <returns></returns>
		ITextArea CreateTextArea(
			// Ext.AbstractComponent
            int? width = null,
            int? height = null,
			string cls = null, 
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// field.Base
			string name = null,

			// form.Labelable
			string fieldLabel = null,
			bool? hideLabel = null
		);

		/// <summary>
		/// 
		/// </summary>
		/// 
		/// Data.AbstractStore
		/// 
		/// <param name="storeId">String
		/// Unique identifier for this store. If present, this Store will be registered with the Ext.data.StoreManager, making it easy to reuse elsewhere.
		/// Note that when store is instatiated by Controller, the storeId will be overridden by the name of the store.
		/// Available since: Ext 4</param>
		/// <param name="defaultProxyType"> String
		/// The string type of the Proxy to create if none is specified. This defaults to creating a memory proxy. Defaults to: 'memory'</param>
		/// <param name="model"> String
		/// Name of the Model associated with this store. The string is used as an argument for Ext.ModelManager.getModel.
		/// Available since: Ext 4</param>
		/// <param name="autoLoad"> Boolean/Object
		/// If data is not specified, and if autoLoad is true or an Object, this store's load method is automatically called after creation. 
		/// If the value of autoLoad is an Object, this Object will be passed to the store's load method.
		/// Available since: Ext 2</param>
		/// <param name="proxy">String/Ext.data.proxy.Proxy/Object
		/// The Proxy to use for this Store. This can be either a string, a config object or a Proxy instance - see setProxy for details.
		/// Available since: Ext 1</param>
		/// <param name="fields">Object[]
		/// This may be used in place of specifying a model configuration. The fields should be a set of Ext.data.Field configuration objects. 
		/// The store will automatically create a Ext.data.Model with these fields. In general this configuration option should only be used for 
		/// simple stores like a two-field store of ComboBox. For anything more complicated, such as specifying a particular id property or associations, 
		/// a Ext.data.Model should be defined and specified for the model config.
		/// Available since: Ext 2</param>
		/// 
		/// Data.Store
		/// 
		/// <param name="remoteSort">True to defer any sorting operation to the server. If false, sorting is done locally on the client.
		/// Defaults to: false 
		/// Available since: Ext 1</param>
		/// <param name="buffered"> Boolean
		/// Allows the Store to prefetch and cache in a page cache, pages of Records, and to then satisfy loading requirements from this page cache.
		/// To use buffered Stores, initiate the process by loading the first page. The number of rows rendered are determined automatically, 
		/// and the range of pages needed to keep the cache primed for scrolling is requested and cached. Example:
		/// myStore.loadPage(1); // Load page 1
		/// A PagingScroller is instantiated which will monitor the scrolling in the grid, and refresh the view's rows from the page cache as needed. 
		/// It will also pull new data into the page cache when scrolling of the view draws upon data near either end of the prefetched data.
		/// The margins which trigger view refreshing from the prefetched data are 
		/// Ext.grid.PagingScroller.numFromEdge, Ext.grid.PagingScroller.leadingBufferZone and Ext.grid.PagingScroller.trailingBufferZone.
		/// The margins which trigger loading more data into the page cache are, leadingBufferZone and trailingBufferZone.
		/// By default, only 5 pages of data are cached in the page cache, with pages "scrolling" out of the buffer as the view moves down through the dataset. 
		/// Setting this value to zero means that no pages are ever scrolled out of the page cache, and that eventually the whole dataset may become present in the page cache. 
		/// This is sometimes desirable as long as datasets do not reach astronomical proportions. 
		/// Selection state may be maintained across page boundaries by configuring the SelectionModel not to discard records from its collection 
		/// when those Records cycle out of the Store's primary collection. This is done by configuring the SelectionModel like this:
		/// selModel: {pruneRemoved: false}
		/// Defaults to: false
		/// Available since: Ext 4</param>
		/// <param name="pageSize">Number
		/// The number of records considered to form a 'page'. This is used to power the built-in paging using the nextPage and previousPage functions 
		/// when the grid is paged using a PagingScroller Defaults to 25.
		/// If this Store is buffered, pages are loaded into a page cache before the Store's data is updated from the cache. 
		/// The pageSize is the number of rows loaded into the cache in one request. This will not affect the rendering of a buffered grid, 
		/// but a larger page size will mean fewer loads. 
		/// In a buffered grid, scrolling is monitored, and the page cache is kept primed with data ahead of the direction of scroll to provide rapid access to 
		/// data when scrolling causes it to be required. Several pages in advance may be requested depending on various parameters.
		/// It is recommended to tune the pageSize, trailingBufferZone and leadingBufferZone configurations based upon the conditions pertaining in your deployed application.
		/// The provided SDK example examples/grid/infinite-scroll-grid-tuner.html can be used to experiment with different settings including simulating Ajax latency.
		/// Available since: Ext 4</param>
		/// <param name="groupField">groupField : String
		/// The field by which to group data in the store. Internally, grouping is very similar to sorting - the groupField and groupDir are injected as the first sorter (see sort). 
		/// Stores support a single level of grouping, and groups can be fetched via the getGroups method.
		/// Available since: Ext 4.1.0</param>
        /// <param name="data">Object[]/Ext.data.Model[]
        /// Array of Model instances or data objects to load locally. See "Inline data" above for details.
        /// Available since: Ext 1</param>
        /// 
		///  <returns></returns>
		IStore CreateDataStore(
            
            // Data.AbstractStore
            string storeId = null,
            StoreProxyType? defaultProxyType = null,
            string model = null,
            bool? autoLoad = null,
            bool? autoSync = null,
            IProxy proxy = null,
			[JsConfig]
            IDataField[] fields = null, 

            // Data.Store
            bool? remoteSort = null, 
            bool? buffered = null,
            int? pageSize = null, 
			string groupField = null,
            Array data = null,
            
            string totalProperty = null
        );


	    /// <summary>
	    /// AjaxProxy is one of the most widely-used ways of getting data into your application. It uses AJAX requests to load data from the server, usually to be placed into a Store.
	    /// A couple of extra configurations appeared here - model and reader. These are set by default when we create the proxy via the Store - the Store already knows 
	    /// about the Model, and Proxy's default Reader is JsonReader.
	    /// Now when we call store.load(), the AjaxProxy springs into action, making a request to the url we configured ('users.json' in this case). As we're performing a read, 
	    /// it sends a GET request to that url (see actionMethods to customize this - by default any kind of read will be sent as a GET request and any kind of write will be sent as 
	    /// a POST request).
	    /// </summary>
	    /// 
	    /// Proxy
	    /// 
        /// <param name="reader">Object/String/Ext.data.reader.Reader
        /// The Ext.data.reader.Reader to use to decode the server's response or data read from client. This can either be a Reader instance, 
        /// a config object or just a valid Reader type name (e.g. 'json', 'xml').
        /// Available since: Ext 4</param>
	    /// 
        /// <param name="writer">The Ext.data.writer.Writer to use to encode any request sent to the server or saved to client. 
        /// This can either be a Writer instance, a config object or just a valid Writer type name (e.g. 'json', 'xml').</param>
        /// 
	    /// ServerProxy
	    /// 
	    /// <param name="url">String
	    /// The URL from which to request the data object.
	    /// Available since: Ext 4</param>
	    /// <param name="timeout">Number
	    /// The number of milliseconds to wait for a response. Defaults to 30000 milliseconds (30 seconds).
	    /// Defaults to: 30000
	    /// Available since: Ext 4</param>
	    /// 
	    /// AjaxProxy
	    /// 
	    /// <param name="actionMethods">actionMethods : Object
	    /// Mapping of action name to HTTP request method. In the basic AjaxProxy these are set to 'GET' for 'read' actions and 'POST' for 'create', 'update' and 'destroy' actions.
	    /// The Ext.data.proxy.Rest maps these to the correct RESTful methods.
	    /// Defaults to: {create: 'POST', read: 'GET', update: 'POST', destroy: 'POST'}
	    /// Available since: Ext 4</param>
	    /// <returns></returns>
	    IAjaxProxy CreateAjaxProxy(

            // Proxy
            IDataReader reader = null,
            IDataWriter writer = null,

            // ServerProxy
            string url = null, 
            int? timeout = null,

            // AjaxProxy
            IActionMethods actionMethods = null
        );

	    IActionMethods ActionMethods(
            HttpMethod? read = null,
            HttpMethod? create = null,
            HttpMethod? update = null,
            HttpMethod? destroy = null
	    );

        /// <summary>
        /// In-memory proxy. This proxy simply uses a local variable for data storage/retrieval, so its contents are lost on every page refresh.
        /// Usually this Proxy isn't used directly, serving instead as a helper to a Store where a reader is required to load data. 
        /// For example, say we have a Store for a User model and have some inline data we want to load, but this data isn't in quite the right format: 
        /// we can use a MemoryProxy with a JsonReader to read it into our Store:
        /// </summary>
        /// 
        /// Proxy
        /// 
        /// <param name="reader">Object/String/Ext.data.reader.Reader
        /// The Ext.data.reader.Reader to use to decode the server's response or data read from client. This can either be a Reader instance, 
        /// a config object or just a valid Reader type name (e.g. 'json', 'xml').
        /// Available since: Ext 4</param>
        /// 
        /// <returns></returns>
	    IMemoryProxy CreateMemoryProxy(
            // Proxy
            IDataReader reader = null

	    );
		/// <summary>
		/// The JSON Reader is used by a Proxy to read a server response that is sent back in JSON format. This usually happens as a result of loading a Store
		///  - for example we might create something like this:
		/// </summary>
		/// 
		/// Reader
		/// 
		/// <param name="messageProperty">String
		/// The name of the property which contains a response message. This property is optional.
		/// Available since: Ext 3</param>
		/// <param name="idProperty"> String
		/// Name of the property within a row object that contains a record identifier value. Defaults to the id of the model. 
		/// If an idProperty is explicitly specified it will take precedence over idProperty defined on the model.
		/// Available since: Ext 4</param>
		/// <param name="totalProperty"> String
		/// Name of the property from which to retrieve the total number of records in the dataset. This is only needed if the whole dataset is not passed in one go, 
		/// but is being paged from the remote server. 
		/// Defaults to: "total"
		/// Available since: Ext 4</param>
		/// 
		/// JsonReader
		/// <param name="root">String
		/// The name of the property which contains the data items corresponding to the Model(s) for which this Reader is configured. 
		/// For JSON reader it's a property name (or a dot-separated list of property names if the root is nested). 
		/// For XML reader it's a CSS selector. For Array reader the root is not applicable since the data is assumed to be a single-level array of arrays.
		/// By default the natural root of the data will be used: the root JSON array, the root XML element, or the array.
		/// The data packet value for this property should be an empty array to clear the data or show no data.
		/// Defaults to: ''
		/// Available since: Ext 1
		/// Overrides: Ext.data.reader.Reader.root</param>
		/// <returns></returns>
		IJsonReader JsonReader(
            // Reader
            string messageProperty = null,
            string idProperty = null,
            string totalProperty = null,
            
            // JsonReader
            string root = null
        );


	    /// <summary>
	    /// This class is used to write Ext.data.Model data to the server in a JSON format. The allowSingle configuration can be set to false 
	    /// to force the records to always be encoded in an array, even if there is only a single record being sent.
	    /// </summary>
	    /// 
	    /// <param name="allowSingle">Configure with false to ensure that records are always wrapped in an array, even if there is only one record being sent. 
	    /// When there is more than one record, they will always be encoded into an array. Defaults to: true</param>
	    /// <param name="dateFormat">This is used for each field of type date in the model to format the value before it is sent to the server.</param>
	    /// <param name="encode">Configure true to send record data (all record fields if writeAllFields is true) as a JSON encoded HTTP parameter named by the root configuration.
	    /// The encode option should only be set to true when a root is defined, because the values will be sent as part of the request parameters as opposed to a raw post. 
	    /// The root will be the name of the parameter sent to the server.Defaults to: false</param>
	    /// <param name="expandData">By default, when dot-delimited field mappings are used (e.g. name: 'myProperty', mapping: 'my.nested.property') 
	    /// the writer will simply output a flat data object containing the mapping string literal as the property name (e.g. { 'my.nested.property': 'foo' }).
	    /// Mappings are used to map incoming nested JSON to flat Ext models. In many case, the data output by the writer should preferrably match the original nested data format. 
	    /// Setting this config to true will ensure that the output will instead look like { my: { nested: { property: 'foo' }}}. The output is generated by getExpandedData, 
	    /// which can optionally be overridden to apply more customized logic.
	    /// Defaults to: false
	    /// </param>
	    /// <param name="nameProperty">This property is used to read the key for each value that will be sent to the server.
	    /// If the value is not present, the field name will always be used.
	    /// Defaults to: 'name'</param>
	    /// <param name="root">The HTTP parameter name by which JSON encoded records will be passed to the server if the encode option is true.</param>
	    /// <param name="writeAllFields">True to write all fields from the record to the server. If set to false it will only send the fields that were modified. 
	    /// Note that any fields that have Ext.data.Field.persist set to false will still be ignored.
	    /// Defaults to: true</param>
	    /// <param name="writeRecordId">By default, each record's id is always included in the output for non-phantom records since in most cases the id will be required on the server 
	    /// to process the record action. This is helpful since the id will normally not be modified, and so would not be sent to the server unless writeAllFields was explicitly enabled.
	    /// However, there are cases where it is not desirable for the record id to be passed in the data directly. For example, when using a RESTful API the record id would typically 
	    /// be appended to the url instead.
	    /// Defaults to: true</param>
	    /// <returns></returns>
	    IJsonWriter JsonWriter(
            bool? allowSingle = null,
            string dateFormat = null,
            bool? encode = null,
            bool? expandData = null,
            string nameProperty = null,
            string root = null,
            bool? writeAllFields = null,
            bool? writeRecordId = null
	    );

        /// <summary>
        /// As the number of records increases, the time required for the browser to render them increases. 
        /// Paging is used to reduce the amount of data exchanged with the client. Note: if there are more records/rows than can be viewed in the available screen area, 
        /// vertical scrollbars will be added. Paging is typically handled on the server side (see exception below). The client sends parameters to the server side, 
        /// which the server needs to interpret and then respond with the appropriate data.
        /// Ext.toolbar.Paging is a specialized toolbar that is bound to a Ext.data.Store and provides automatic paging control. 
        /// This Component loads blocks of data into the store by passing parameters used for paging criteria.
        /// </summary>
        /// 
		/// AbstractContainer
		/// 
		/// <param name="items">Object/Object[]
		/// A single item, or an array of child Components to be added to this container
		/// Unless configured with a layout, a Container simply renders child Components serially into its encapsulating element and performs no sizing or positioning upon them.</param>
		/// <param name="layout"> Ext.enums.Layout/Object
		/// Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specified through the layout configuration option.
		/// The sizing and positioning of child items is the responsibility of the Container's layout manager which creates and manages the type of layout you have in mind. For example:
		/// If the layout configuration is not explicitly specified for a general purpose container (e.g. Container or Panel) the default layout manager will be used which does nothing 
		/// but render child components sequentially into the Container (no sizing or positioning will be performed in this situation).</param>
		/// 
		/// 
        /// PagingToolbar
        /// 
        /// <param name="store">store : Ext.data.Store required
        /// The Ext.data.Store the paging toolbar should use as its data source.
        /// Available since: Ext 2</param>
        /// 
        /// <param name="displayInfo">Boolean
        /// true to display the displayMsg 
        /// Defaults to: false
        /// Available since: Ext 1</param>
        /// <param name="displayMsg">String
        /// The paging status message to display. Note that this string is formatted using the braced numbers {0}-{2} as tokens that are replaced by the values for start, 
        /// end and total respectively. These tokens should be preserved when overriding this string if showing those values is desired.
        /// Defaults to: 'Displaying {0} - {1} of {2}'
        /// Available since: Ext 1</param>
        /// <param name="emptyMsg">The message to display when no records are found.
        /// Defaults to: 'No data to display'
        /// Available since: Ext 1</param>
        /// <param name="items"></param>
        /// <returns></returns>
	    IPagingToolbar CreatePagingToolbar(

            // PagingToolbar
            IStore store = null, 
            bool? displayInfo = null, 
            string displayMsg = null, 
            string emptyMsg = null, 

			// AbstractContainer
			IBase[] items = null,
			[JsConfig]
            ILayout layout = null

		);

		/// <summary>
		/// This feature allows to display the grid rows aggregated into groups as specified by the Ext.data.Store.groupers specified on the Store. 
		/// The group will show the title for the group name and then the appropriate records for the group underneath. The groups can also be expanded and collapsed.
		/// </summary>
		/// <param name="collapsible">Boolean
		/// Set to falsee to disable collapsing groups from the UI.
		/// This is set to false when the associated store is buffered.
		/// Defaults to: true
		/// Available since: Ext 4.1.1</param>
		/// <param name="depthToIndent">depthToIndent : Number
		/// Number of pixels to indent per grouping levelDefaults to: 17
		/// Available since: Ext 4</param>
		/// <param name="enableGroupingMenu">Boolean
		/// True to enable the grouping control in the header menu.
		/// Defaults to: true
		/// Available since: Ext 4</param>
		/// <param name="enableNoGroups">Boolean
		/// True to allow the user to turn off grouping.
		/// Defaults to: true
		/// Available since: Ext 4</param>
		/// <param name="groupByText">String 
		/// Text displayed in the grid header menu for grouping by header.
		/// Defaults to: "Group by this field"
		/// Available since: Ext 4</param>
		/// <param name="groupHeaderTpl">String/Array/Ext.Template
		/// A string Template snippet, an array of strings (optionally followed by an object containing Template methods) to be used to construct a Template, or a Template instance.</param>
		/// <param name="hideGroupedHeader">Boolean
		/// True to hide the header that is currently grouped.
		/// Defaults to: false
		/// Available since: Ext 4</param>
		/// <param name="showGroupsText">String
		/// Text displayed in the grid header for enabling/disabling grouping.
		/// Defaults to: "Show in groups"
		/// Available since: Ext 4</param>
		/// <param name="startCollapsed">Boolean
		/// True to start all groups collapsed.
		/// Defaults to: false
		/// Available since: Ext 4</param>
		/// <returns></returns>
		IGridGrouping GroupingFeature(
			bool? collapsible = null,
			int? depthToIndent = null,
			bool? enableGroupingMenu = null,
			bool? enableNoGroups = null,
			string groupByText = null,
			string groupHeaderTpl = null,
			bool? hideGroupedHeader = null,
			string showGroupsText = null,
			bool? startCollapsed = null
		);

		/// <summary>
		/// The Ext.grid.plugin.CellEditing plugin injects editing at a cell level for a Grid. Only a single cell will be editable at a time. 
		/// The field that will be used for the editor is defined at the editor. The editor can be a field instance or a field configuration.
		/// If an editor is not specified for a particular column then that cell will not be editable and it will be skipped when activated via the mouse or the keyboard.
		/// The editor may be shared for each column in the grid, or a different one may be specified for each column. An appropriate field type 
		/// should be chosen to match the data structure that it will be editing. For example, to edit a date, it would be useful to specify Ext.form.field.Date as the editor.
		/// </summary>
		/// 
		/// grid.plugin.Editing	
		/// 
		///  <param name="clicksToEdit">The number of clicks on a grid required to display the editor. The only accepted values are 1 and 2.
		/// Defaults to: 2
		/// Available since: Ext 4</param>
		/// <returns></returns>
		ICellEditing CellEditing(
			// grid.plugin.Editing	
			int? clicksToEdit = null
		);

	    ColumnRenderer DateRenderer(string format);

	    /// <summary>
	    /// Tracks what records are currently selected in a databound component.
	    /// This is an abstract class and is not meant to be directly used. Databound UI widgets such as Grid and Tree should subclass Ext.selection.Model and provide a way to binding to the component.
	    /// The abstract methods onSelectChange and onLastFocusChanged should be implemented in these subclasses to update the UI widget.
	    /// Available since: Ext 4
	    /// </summary>
	    /// 
	    /// selection.Model
	    ///  
	    /// <param name="allowDeselect">allowDeselect : Boolean
	    /// Allow users to deselect a record in a DataView, List or Grid. Only applicable when the mode is 'SINGLE'.
	    /// Defaults to: false
	    /// Available since: Ext 4</param>
	    /// <param name="mode"> "SINGLE"/"SIMPLE"/"MULTI"
	    /// Mode of selection</param>
	    /// <returns></returns>
	    ICellSelection CellSelection(
            // selection.Model
            bool? allowDeselect = null,
            SelectionMode? mode = null 
        );

	    /// <summary>
	    /// Implements row based navigation via keyboard.
	    /// Must synchronize across grid sections.
	    /// Available since: Ext 4
	    /// </summary>
	    ///  
	    /// selection.Model
	    ///  
	    /// <param name="allowDeselect">allowDeselect : Boolean
	    /// Allow users to deselect a record in a DataView, List or Grid. Only applicable when the mode is 'SINGLE'.
	    /// Defaults to: false
	    /// Available since: Ext 4</param>
	    /// <param name="mode"> "SINGLE"/"SIMPLE"/"MULTI"
	    /// Mode of selection</param>
	    /// 
	    /// selection.RowModel
	    /// <param name="enableKeyNav">Boolean
	    /// Turns on/off keyboard navigation within the grid.
	    /// Defaults to: true
	    /// Available since: Ext 4</param>
	    /// <param name="ignoreRightMouseSelection">Boolean
	    /// True to ignore selections that are made when using the right mouse button if there are records that are already selected. If no records are selected, 
	    /// selection will continue as normal
	    /// Defaults to: false
	    /// Available since: Ext 4</param>
	    /// <returns></returns>
	    IRowSelection RowSelection(
            // selection.Model
            bool? allowDeselect = null,
            SelectionMode? mode = null,
 
            // selection.RowModel
            bool? enableKeyNav = null,
            bool? ignoreRightMouseSelection = null
        );

		IXTemplate XTemplate(
			string html
		);

		/// <summary>
		/// Base class for all Ext components.
		/// The Component base class has built-in support for basic hide/show and enable/disable and size control behavior.
		/// </summary>
		/// 
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// <returns></returns>
		IComponent CreateComponent(
			// Ext.AbstractComponent
            int? width = null,
            int? height = null,
			string cls = null, 
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,
            string renderTo = null
		);

        /// <summary>
        /// An internally used DataView for ComboBox.
        /// Available since: Ext 4
        /// </summary>
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4
		/// </param>
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		/// 
        /// 
        /// view.AbstractView
        /// 
        /// <param name="itemTpl">String/String[]/Ext.XTemplate
        /// The inner portion of the item template to be rendered. Follows an XTemplate structure and will be placed inside of a tpl.
        /// Available since: Ext 4</param>
        /// 
        /// 
        /// 
        /// <param name="emptyText">String
        /// The text to display in the view when there is no data to display. Note that when using local data the emptyText will not be displayed unless you set the 
        /// deferEmptyText option to false. Defaults to: ""
        /// Available since: Ext 2</param>
        /// <param name="itemSelector">String, required
        /// This is a required setting. A simple CSS selector (e.g. div.some-class or span:first-child) that will be used to determine what nodes this DataView will be working with. 
        /// The itemSelector is used to map DOM nodes to records. As such, there should only be one root level element that matches the selector for each record.
        /// Available since: Ext 2</param>
        /// <param name="loadingText">String
        /// A string to display during data load operations. If specified, this text will be displayed in a loading div and the view's contents will be cleared while loading, 
        /// otherwise the view's contents will continue to display normally until the new data is loaded and the contents are replaced.
        /// Defaults to: 'Loading...'
        /// Available since: Ext 2</param>
        /// <param name="minWidth">Number
        /// The minimum value in pixels which this Component will set its width to.
        /// Warning: This will override any size management applied by layout managers.
        /// Default: 70
        /// Available since: Ext 4</param>
        /// <param name="maxWidth">Number
        /// The maximum value in pixels which this Component will set its width to.
        /// Warning: This will override any size management applied by layout managers.
        /// Available since: Ext 4</param>
        /// <param name="maxHeight">Number
        /// The maximum value in pixels which this Component will set its height to.
        /// Warning: This will override any size management applied by layout managers.
        /// Available since: Ext 4</param>
        /// <param name="resizable">Boolean/Object
        /// Specify as true to apply a Resizer to this Component after rendering.
        /// May also be specified as a config object to be passed to the constructor of Resizer to override any defaults. 
        /// By default the Component passes its minimum and maximum size, and uses Ext.resizer.Resizer.dynamic: false
        /// Available since: Ext 4</param>
        /// <param name="shadow">String/Boolean
        /// Specifies whether the floating component should be given a shadow. Set to true to automatically create an Ext.Shadow, or a string indicating the shadow's display Ext.Shadow.mode. 
        /// Set to false to disable the shadow.
        /// Defaults to: false
        /// Available since: Ext 4
        /// Overrides: Ext.util.Floating.shadow</param>
        /// <param name="tpl">String/Ext.XTemplate
        /// A String or Ext.XTemplate instance to apply to inner template.
        /// Ext.view.BoundList is used for the dropdown list of Ext.form.field.ComboBox. </param>
        /// <returns></returns>
        IBoundList BoundList(  
        
            // Ext.AbstractComponent
            int? width = null,
            int? height = null,
            string cls = null,
            string style = null,
            string html = null,
            string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

            string emptyText = null,
            string itemSelector = null,
            string loadingText = null,
            int? minWidth = null,
            int? maxWidth = null,
            int? maxHeight = null,
            bool? resizable = null,
            Shadow shadow = null,
            string tpl = null,
            string itemTpl = null
        );

		/// <summary>
		/// This is a multi-pane, application-oriented UI layout style that supports multiple nested panels, automatic bars between regions and built-in expanding and collapsing of regions.
		/// This class is intended to be extended or created via the layout:'border' Ext.container.Container.layout config, and should generally not need to be created directly via the new keyword.
		/// </summary>
		/// <param name="padding">Number/String/Object
		/// Sets the padding to be applied to all child items managed by this layout.
		/// This property can be specified as a string containing space-separated, numeric padding values. The order of the sides associated with each value matches the way CSS processes padding values:
		/// If there is only one value, it applies to all sides.
		/// If there are two values, the top and bottom borders are set to the first value and the right and left are set to the second.
		/// If there are three values, the top is set to the first value, the left and right are set to the second, and the bottom is set to the third.
		/// If there are four values, they apply to the top, right, bottom, and left, respectively.
		/// Available since: Ext 4.1.0</param>
		/// <returns></returns>
		IBorderLayout BorderLayout(
			Padding padding = null
		);
		
		ITableLayout TableLayout(
		);

		/// <summary>
		/// The TreeStore is a store implementation that is backed by by an Ext.data.Tree. It provides convenience methods for loading nodes, 
		/// as well as the ability to use the hierarchical tree structure combined with a store. 
		/// This class is generally used in conjunction with Ext.tree.Panel. This class also relays many events from the Tree for convenience.
		/// </summary>
		/// <returns></returns>
		ITreeStore CreateTreeStore(
			[JsConfig]
			INodeInterface root);

		/// <summary>
		/// This class is used as a set of methods that are applied to the prototype of a Model to decorate it with a Node API. This means that models used 
		/// in conjunction with a tree will have all of the tree related methods available on the model. In general this class will not be used directly by the developer. 
		/// This class also creates extra fields on the model if they do not exist, to help maintain the tree state and UI. These fields are documented as config options.
		/// Available since: Ext 4
		/// </summary>
		/// <param name="href">String
		/// An URL for a link that's created when this config is specified.
		/// Available since: Ext 4</param>
		/// <param name="hrefTarget">String
		/// Target for link. Only applicable when href also specified.
		/// Available since: Ext 4</param>
		/// <param name="text">String
		/// The text for to show on node label.
		/// Available since: Ext 4</param>
		/// <param name="leaf">Boolean
		/// Set to true to indicate that this child can have no children. The expand icon/arrow will then not be rendered for this node.
		/// Defaults to: false
		/// Available since: Ext 4</param>
		/// <param name="index">Number
		/// The position of the node inside its parent. When parent has 4 children and the node is third amongst them, index will be 2.
		/// Available since: Ext 4</param>
		/// <param name="allowDrag">Boolean
		/// Set to false to deny dragging of this node.
		/// Defaults to: true
		/// Available since: Ext 4</param>
		/// <param name="checked">Boolean
		/// Set to true or false to show a checkbox alongside this node.
		/// Defaults to: null
		/// Available since: Ext 4</param>
		/// <param name="allowDrop">Boolean
		/// Set to false to deny dropping on this node.
		/// Defaults to: true
		/// Available since: Ext 4</param>
		/// <param name="cls">String
		/// CSS class to apply for this node.
		/// Available since: Ext 4</param>
		/// <param name="expandable">Boolean
		/// Set to true to allow for expanding/collapsing of this node.
		/// Defaults to: false
		/// Available since: Ext 4</param>
		/// <param name="expanded">Boolean
		/// True if the node is expanded.
		/// Defaults to: false
		/// Available since: Ext 4</param>
		/// <param name="depth">Number
		/// The number of parents this node has. A root node has depth 0, a child of it depth 1, and so on...
		/// Available since: Ext 4</param>
		/// <param name="icon">String
		/// URL for this node's icon.
		/// Available since: Ext 4</param>
		/// <param name="iconCls">String
		/// CSS class to apply for this node's icon.
		/// Available since: Ext 4</param>
		/// <param name="qtip">String
		/// Tooltip text to show on this node.
		/// Available since: Ext 4</param>
		/// <param name="qtitle">String
		/// Tooltip title.
		/// Available since: Ext 4</param>
		/// <param name="root">Boolean
		/// True if this is the root node.
		/// Available since: Ext 4</param>
		/// <param name="isFirst">Boolean
		/// True if this is the first node.
		/// Available since: Ext 4</param>
		/// <param name="isLast">Boolean
		/// True if this is the last node.
		/// Available since: Ext 4</param>
		/// <param name="loaded">Boolean
		/// True if the node has finished loading.
		/// Defaults to: false
		/// Available since: Ext 4</param>
		/// <param name="loading">Boolean
		/// True if the node is currently loading.
		/// Defaults to: false
		/// Available since: Ext 4</param>
		/// <param name="children">Ext.data.NodeInterface[]
		/// Array of child nodes.
		/// Available since: Ext 4</param>
		/// <returns></returns>
		INodeInterface Node(
			string href = null,
			string hrefTarget = null,
			string text = null,
			bool? leaf = null,
			int? index = null,
			bool? allowDrag = null,
			bool? @checked = null,
			bool? allowDrop = null,
			string cls = null,
			bool? expandable = null,
			bool? expanded = null,
			int? depth = null,
			string icon = null,
			string iconCls = null,
			string qtip = null,
			string qtitle = null,
			bool? root = null,
			bool? isFirst = null,
			bool? isLast = null,
			bool? loaded = null,
			bool? loading = null,
			[JsConfig]
			INodeInterface[] children = null
		);

		/// <summary>
		/// 
		/// </summary>
		/// 
		/// Ext.AbstractComponent
		/// 
		/// <param name="width">Number
		/// The width of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="height">Number
		/// The height of this component in pixels.
		/// Available since: Ext 4</param>
		/// <param name="cls">An optional extra CSS class that will be added to this component's Element. 
		/// This can be useful for adding customized styles to the component or any of its children using standard CSS rules.</param>
		/// <param name="style">String/Object
		/// A custom style specification to be applied to this component's Element. Should be a valid argument to Ext.Element.applyStyles.</param>
		/// <param name="html">String/Object
		/// An HTML fragment, or a DomHelper specification to use as the layout element content. The HTML content is added after the component is rendered, 
		/// so the document will not contain this HTML at the time the render event is fired. This content is inserted into the body before any configured contentEl is appended.
		/// Defaults to: ''
		/// Available since: Ext 3</param>
		/// <param name="id">String
		/// The unique id of this component instance.
		/// It should not be necessary to use this configuration except for singleton objects in your application. Components created with an id may be accessed globally using Ext.getCmp.
		/// Instead of using assigned ids, use the itemId config, and ComponentQuery which provides selector-based searching for Sencha Components analogous to DOM querying. 
		/// The Container class contains shortcut methods to query its descendant Components by selector.
		/// Note that this id will also be used as the element id for the containing HTML element that is rendered to the page for this component. 
		/// This allows you to write id-based CSS rules to style the specific instance of this component uniquely, and also to select sub-elements using this component's id as the parent.
		/// Note: To avoid complications imposed by a unique id also see itemId.
		/// Note: To access the container of a Component see ownerCt.
		/// Defaults to an auto-assigned id.
		/// Available since: Ext 1</param>
		/// <param name="loader">Ext.ComponentLoader/Object
		/// A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component.</param>
		/// <param name="flex">Attached property from Ext.layout.container.Box
		/// Number 
		/// This configuration option is to be applied to child items of the container managed by this layout. Each child item with a flex property will be flexed 
		/// (horizontally in hbox, vertically in vbox) according to each item's relative flex value compared to the sum of all items with a flex value specified. 
		/// Any child items that have either a flex = 0 or flex = undefined will not be 'flexed' (the initial size will not be changed).
		/// Available since: Ext 4</param>		
		/// <param name="anchor">Attached property from Ext.layout.container.Anchor
		/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
		/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of anchor which is
		/// a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:</param>
		///  
		/// AbstractContainer
		/// 
		/// <param name="items">Object/Object[]
		/// A single item, or an array of child Components to be added to this container
		/// Unless configured with a layout, a Container simply renders child Components serially into its encapsulating element and performs no sizing or positioning upon them.</param>
		/// <param name="layout"> Ext.enums.Layout/Object
		/// Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specified through the layout configuration option.
		/// The sizing and positioning of child items is the responsibility of the Container's layout manager which creates and manages the type of layout you have in mind. For example:
		/// If the layout configuration is not explicitly specified for a general purpose container (e.g. Container or Panel) the default layout manager will be used which does nothing 
		/// but render child components sequentially into the Container (no sizing or positioning will be performed in this situation).</param>
		/// 
		/// 
		/// <param name="?"></param>
		/// <returns></returns>
		IContainer Container(
			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,

			// AbstractContainer
			IBase[] items = null,
			[JsConfig]
            ILayout layout = null
		);

		/// <summary>
		/// 
		/// </summary>
		/// <param name="autoCancel">true to automatically cancel any pending changes when the row editor begins editing a new row. false to force the user to explicitly cancel 
		/// the pending changes. Defaults to: true Available since: 4.0.0</param>
		/// <param name="clicksToEdit">The number of clicks on a grid required to display the editor. The only accepted values are 1 and 2. Defaults to: 2</param>
		/// <param name="clicksToMoveEditor">The number of clicks to move the row editor to a new row while it is visible and actively editing another row. This will default to the same value as clicksToEdit.</param>
		/// <param name="errorSummary">True to show a tooltip that summarizes all validation errors present in the row editor. Set to false to prevent the tooltip from showing. Defaults to: true. Available since: 4.0.0</param>
		/// <returns></returns>
		IGridPluginRowEditing CreateGridPluginRowEditing(
			bool? autoCancel = null,
			int? clicksToEdit = null, 
			int? clicksToMoveEditor = null, 
			bool? errorSummary = null 
		);

		IWindow CreateWindow(
			// Ext.AbstractComponent
			int? width = null,
			int? height = null,
			string cls = null,
			string style = null,
			string html = null,
			string id = null,
			IComponentLoader loader = null,
			int? flex = null,
			Anchor anchor = null,
			// AbstractContainer
			IBase[] items = null,
			bool? plain = null,
			HeaderPosition? headerPosition = null,
			[JsConfig]
            ILayout layout = null,
			CloseAction? closeAction = null,
			bool? modal = null,
		    Border border = null
		);


		T Direct<T>();
	}

    public enum BoxLabelAlign
    {
        Before,
        After
    }

    public enum CloseAction
	{
		Hide,
		Destroy
	}

	[JsClass("Ext.window.Window", "window")]
	public interface IWindow : IPanelPanel
	{
	}

	[JsClass("Ext.toolbar.TextItem", "tbtext")]
	public interface IToolbarText : IToolbarItem
	{
	}

	public interface IToolbarItem : IComponent
	{
	}


	[JsClass("Ext.form.field.Hidden", "hiddenfield")]
	public interface IHiddenField : IFormFieldBase
	{
	}

	public enum ColumnAlign
    {
        Left, 
        Center, 
        Right
    }

    [JsClass("Ext.form.field.Date","datefield")]
	public interface IDateField : IPicker
	{
	}

	[JsClass("Ext.form.field.Checkbox","checkbox")]
	public interface ICheckboxField : IFormFieldBase
	{
	}


	public enum AnchorSide
	{
		Right,
		Bottom
	}

	public enum HeaderPosition
	{
		Top,
		Left, 
		Right,
		Bottom
	}


	public static class PercentsExt
	{
		public static Percents Percents(this int value)
		{
			return new Percents(value);
		}
	}

	public class Percents
	{
		public Percents(int value)
		{
			Value = value;
		}

		public int Value { get; private set; }
	}
	/// <summary>
	/// This configuation option is to be applied to child items of a container managed by this layout (ie. configured with layout:'anchor').
	/// This value is what tells the layout how an item should be anchored to the container. items added to an AnchorLayout accept an anchoring-specific config property of 
	/// anchor which is a string containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%'). The following types of anchor values are supported:
	///	Percentage :		Any value between 1 and 100, expressed as a percentage. The first anchor is the percentage width that the item should take up within the container, 
	///						and the second is the percentage height. For example: two values specified anchor: '100% 50%' render item complete width of the container and 1/2 height of the container
    ///						one value specified anchor: '100%' - the width value; the height will default to auto
	/// Offsets :			Any positive or negative integer value. This is a raw adjustment where the first anchor is the offset from the right edge of the container, 
	///						and the second is the offset from the bottom edge. For example: two values specified: anchor: '-50 -100' // render item the complete width of the container
	///						// minus 50 pixels and the complete height minus 100 pixels. one value specified anchor: '-50'      // anchor value is assumed to be the right offset value bottom offset will default to 0
	/// Sides :				Valid values are right (or r) and bottom (or b).Either the container must have a fixed size or an anchorSize config value defined at render time in order for these to have any effect.
	/// Mixed :				Anchor values can also be mixed as needed. For example, to render the width offset from the container right edge by 50 pixels and 75% of the container's height use:
	///					    anchor:   '-50 75%'


	/// </summary>
	public class Anchor: IProvidesValue
	{
		public Anchor(object value)
		{
			Value = value;
		}

		public object Value { get; private set; }

		public static implicit operator Anchor(AnchorSide side)
		{
			return new Anchor(side.ToString());
		}

		public static implicit operator Anchor(Percents percents)
		{
			return new Anchor(percents.Value.ToString() + "%");
		}

		public static implicit operator Anchor(int offset)
		{
			return new Anchor(offset);
		}
	}

	public enum LabelTarget
	{
		/// <summary>
		/// Display a quick tip containing the message when the user hovers over the field. This is the default.
		///	Ext.tip.QuickTipManager.init must have been called for this setting to work.
		/// </summary>
		Qtip,
		/// <summary>
		/// Display the message in a default browser title attribute popup.
		/// </summary>
		Title,
		/// <summary>
		/// Add a block div beneath the field containing the error message.
		/// </summary>
		Under,
 		/// <summary>
		/// Add an error icon to the right of the field, displaying the message in a popup on hover.
 		/// </summary>
		Side,
 		/// <summary>
		/// Don't display any error message. This might be useful if you are implementing custom error display.
 		/// </summary>
		None
	}

	public enum LabelAlign
	{
		Left, Top, Right
	}

	/// <summary>
	/// Barebones iframe implementation. For serious iframe work, see the ManagedIFrame extension (http://www.sencha.com/forum/showthread.php?71961).
	/// Available since: Ext 4.1.0
	/// </summary>
	[JsClass("Ext.ux.IFrame", "uxiframe")]
	public interface IFrame : IComponent
	{
	}

	[JsClass("Ext.tree.Panel","treepanel")]
	public interface ITreePanel : IPanelTable
	{
	}

	[JsClass("Ext.data.NodeInterface", null)]
	public interface INodeInterface
	{
	    string href { get; }
		string hrefTarget { get; }
		string text { get; }
		bool leaf { get; }
		int index { get; }
		bool allowDrag { get; }
		bool @checked { get; }
		bool allowDrop { get; }
		string cls { get; }
		bool expandable { get; }
		bool expanded { get; }
		int depth { get; }
		string icon { get; }
		string iconCls { get; }
		string qtip { get; }
		string qtitle { get; }
		bool root { get; }
		bool isFirst { get; }
		bool isLast { get; }
		bool loaded { get; }
		bool loading { get; }
        INodeInterface[] children { get; }
	}

	[JsClass("Ext.grid.column.TemplateView", "templatecolumn")]
	public interface ITemplateColumn : IColumn
	{

	}

	[JsClass("Ext.grid.column.NumberView","numbercolumn")]
	public interface INumberColumn : IColumn
	{
	}

	[JsClass("Ext.grid.column.DateView", "datecolumn")]
	public interface IDateColumn : IColumn
	{
	}

	[JsClass("Ext.grid.column.BooleanView source", "checkcolumn")]
	public interface IBooleanColumn : IColumn
	{
	}

	[JsClass("Ext.layout.container.TableView", "table")]
	public interface ITableLayout : ILayoutContainer 
	{
	}

	[JsClass("Ext.layout.container.BorderView", "border")]
	public interface IBorderLayout : ILayoutContainer
	{
	}

	[JsClass("Ext.layout.container.Container", null)]
	public interface ILayoutContainer : ILayout
	{
	}

	/// <summary>
	/// Specify it for parameters that provide configuration rather than constructor with this configuration
	/// </summary>
	[AttributeUsage(AttributeTargets.Parameter)]
	public class JsConfigAttribute : Attribute
	{
	}


    /// <summary>
	/// A template class that supports advanced functionality like:
	///		Autofilling arrays using templates and sub-templates
	///		Conditional processing with basic comparison operators
	///		Basic math function support
	///		Execute arbitrary inline code with special built-in template variables
	///		Custom member functions
	/// Many special tags and built-in operators that aren't defined as part of the API, but are supported in the templates that can be created
	/// XTemplate provides the templating mechanism built into Ext.view.View.
	/// </summary>
    [JsClass("Ext.XTemplate", null)]
	public interface IXTemplate : ITemplate
	{
	}

	[JsClass("Ext.Template", null)]
	public interface ITemplate : IBase
	{
	}

	public class Shadow: IProvidesValue
	{
		public object Value { get; private set; }

		public static implicit operator Shadow(bool on)
		{
			return new Shadow {Value = on};
		}

		public static implicit operator Shadow(ShadowMode mode)
		{
			return new Shadow {Value = mode};
		}
	}

	public enum ShadowMode
	{
		/// <summary>
		/// Shadow displays on both sides and bottom only
		/// </summary>
		Sides,
		/// <summary>
		/// Shadow displays equally on all four sides
		/// </summary>
		Frame,
		/// <summary>
		/// Traditional bottom-right drop shadow
		/// </summary>
		Drop 
	}

    [JsClass("Ext.view.BoundList", "boundlist")]
	public interface IBoundList: IView
	{
	}

	public enum SelectionMode
    {
        /// <summary>
        /// Only allows selecting one item at a time. Use allowDeselect to allow deselecting that item. This is the default.
        /// </summary>
        Single,
        /// <summary>
        /// Allows simple selection of multiple items one-by-one. Each click in grid will either select or deselect an item.
        /// </summary>
        Simple,
        /// <summary>
        /// Allows complex selection of multiple items using Ctrl and Shift keys.
        /// </summary>
        Multi, 
    }

	public delegate void MenuItemHandler(IMenuItem item, EventObject e);
    public delegate void TreeSelectionChange(ISelectionModel model, ITreeModel[] selected, object eOpts);
    /// <summary>
    /// Tracks what records are currently selected in a databound component.
    /// This is an abstract class and is not meant to be directly used. Databound UI widgets such as Grid and Tree should subclass Ext.selection.Model and provide a way to binding to the component.
    /// The abstract methods onSelectChange and onLastFocusChanged should be implemented in these subclasses to update the UI widget.
    /// Available since: Ext 4
    /// </summary>
    [JsClass("Ext.selection.Model", null)]
    public interface ISelectionModel : IObservable
    {
		TreeSelectionChange selectionchange { get; set; }
        IModel[] getSelection();
    }

    [JsClass("Ext.selection.CellModel", "cellmodel")]
    public interface ICellSelection : ISelectionModel
    {
    }

    [JsClass("Ext.selection.DataViewModel", null)]
    public interface IDataViewSelection : ISelectionModel
    {
    }

    [JsClass("Ext.selection.RowModel", "rowmodel")]
    public interface IRowSelection : ISelectionModel
    {
	    IModel[] getSelection(); 
    }

    
    public class KnownCellEditor : IFormFieldBase, IProvidesValue
    {
        private readonly string knownName;

        public KnownCellEditor(string knownName)
        {
            this.knownName = knownName;
        }

        public object Value {
            get { return knownName;}
        }

        public static IFormFieldBase TextField = new KnownCellEditor("textfield");
        public object getValue()
        {
            return null;
        }
    }


    [JsClass("Ext.data.proxy.Memory", "memory")]
    public interface IMemoryProxy: IClientProxy
    {
    }


	/// <summary>
	/// A renderer is an 'interceptor' method which can be used to transform data (value, appearance, etc.) before it is rendered
	/// </summary>
	/// <param name="?"></param>
	/// <param name="value">The data value for the current cell</param>
	/// <param name="metadata">A collection of metadata about the current cell; can be used or modified by the renderer. Recognized properties are: tdCls, tdAttr, and style.</param>
	/// <param name="record">Ext.data.Model. The record for the current row</param>
	/// <param name="rowIndex">The index of the current row</param>
	/// <param name="colIndex">The index of the current column</param>
	/// <param name="store">The data store</param>
	/// <param name="view">The current view</param>
	/// <returns>The HTML string to be rendered.</returns>
	public delegate string OnColumnRender(object value, object metadata, IModel record, int rowIndex, int colIndex, IStore store, IView view);

    public class ColumnRenderer : IProvidesValue
    {
        public object Value { get; private set; }

        public static implicit operator ColumnRenderer(Expression<OnColumnRender> callback)
        {
            return new ColumnRenderer {Value = callback};
        }
    }

	public delegate void CellBeforeEdit(ICellEditing editor, object e, object eOpts);

    [JsClass("Ext.grid.plugin.CellEditing", "cellediting")]
	public interface ICellEditing : IGridEditing
	{
	    Expression<CellBeforeEdit> beforeedit { get; set; }
		IMixedCollection editors { get; set; } 
	}

    [JsClass("Ext.grid.plugin.Editing", "editing")]
	public interface IGridEditing : IPlugin
	{
	}

	[JsClass("Ext.AbstractPlugin", null)]
	public interface IPlugin : IBase
	{
	}

    [JsClass("Ext.grid.feature.Grouping", "grouping")]
	public interface IGridGrouping : IGridFeature 
	{
	}

    [JsClass("Ext.grid.feature.Feature", "feature")]
	public interface IGridFeature : IObservable
	{
	}

	public interface IObservable : IBase
	{
	}

    [JsClass("Ext.toolbar.Paging", "pagingtoolbar")]
    public interface IPagingToolbar : IToolbar
    {
        IButton refresh { get; set; }
    }

    [JsClass("Ext.data.reader.Reader", null)]
    public interface IDataReader : IBase
    {
    }

    [JsClass("Ext.data.reader.Json", "json")]
    public interface IJsonReader: IDataReader
    {
    }

    [JsClass("Ext.data.writer.Writer", null)]
    public interface IDataWriter : IBase
    {
    }

    [JsClass("Ext.data.writer.Json", "json")]
    public interface IJsonWriter : IDataWriter
    {
    }

    public enum HttpMethod
    {
        Get,
        Post,
        Delete
    }

    public interface IActionMethods
    {
    }

    public enum StoreProxyType
    {
        Memory
    }

    public class Padding : IProvidesValue
    {
        public Padding(object value)
        {
            Value = value;
        }

        public static implicit operator Padding(int oneForAll)
        {
            return new Padding(oneForAll);    
        }
        
        public static implicit operator Padding(string asString)
        {
            return new Padding(asString);    
        }

        public object Value { get; private set; }
    }

    /// <summary>
    /// border : Number/String/Boolean
    /// Specifies the border size for this component. The border can be a single numeric value to apply to all sides or 
    /// it can be a CSS style specification for each style, for example: '10 5 3 10' (top, right, bottom, left).
    /// For components that have no border by default, setting this won't make the border appear by itself. You also need to specify border color and style:
    /// border: 5,
    /// style: {
    ///     borderColor: 'red',
    ///     borderStyle: 'solid'
    /// }
    /// </summary>
    public class Border : IProvidesValue
    {
        public Border(object value)
        {
            Value = value;
        }

        public static implicit operator Border(int oneForAll)
        {
            return new Border(oneForAll);    
        }

        public static implicit operator Border(bool yesOrNo)
        {
            return new Border(yesOrNo);    
        }

        public static implicit operator Border(string asString)
        {
            return new Border(asString);    
        }

        public object Value { get; private set; }
    }

    [JsClass("Ext.form.TextArea", "textarea")]
	public interface ITextArea : ITextField
	{
	}

	public enum ComboBoxQueryMode
	{
		/// <summary>
		/// In queryMode: 'remote', the ComboBox loads its Store dynamically based upon user interaction.
		/// This is typically used for "autocomplete" type inputs, and after the user finishes typing, the Store is loaded.
		/// A parameter containing the typed string is sent in the load request. The default parameter name for the input string is query, but this can be configured using the queryParam config.
		/// In queryMode: 'remote', the Store may be configured with remoteFilter: true, and further filters may be programatically added to the Store which are then passed 
		/// with every load request which allows the server to further refine the returned dataset.
		/// Typically, in an autocomplete situation, hideTrigger is configured true because it has no meaning for autocomplete.
		/// </summary>
		Remote,
		/// <summary>
		/// ComboBox loads local data
		/// </summary>
		Local
	}

    public delegate void ComboboxSelect(IComboBox combo, IModel[] records, object eOpt);

    [JsClass("Ext.form.ComboBox", "combo")]
	public interface IComboBox : IPicker
	{
        Expression<ComboboxSelect> select{ get; set; }
	}

	public interface IPicker : ITrigger
	{
	}

	public interface ITrigger : ITextField
	{
	}

    [JsClass("Ext.form.field.Text", "textfield")]
	public interface ITextField : IFormFieldBase
	{
	}

    [JsClass("Ext.form.field.Base", null)]
	public interface IFormFieldBase : IComponent
	{
        object getValue();
	}

    [JsClass("Ext.Component", "box")]
	public interface IComponent : IAbstractComponent
	{
	}

	public interface IAbstractComponent : IBase
	{
	}


	public interface IContainerLayout
	{
	}

	public interface ILabelable
	{
	}

    public delegate void AfterRenderEvent(object e, object eOpts);

	[JsClass("Ext.form.Panel", "form")]
	public interface IFormPanel : IPanelPanel
	{
		/// <summary>
		///  Provides access to the Form which this Panel contains.
		/// Available since: Ext 2
		/// </summary>
		/// <returns>Ext.form.Basic 
		/// The Form which this Panel contains.</returns>
		IBasicForm getForm();

        Expression<AfterRenderEvent> afterrender { get; set; }
	}

	[JsClass("Ext.form.Basic", null)]
	public interface IBasicForm
	{
		void submit();
	    bool standardSubmit { get; set; }
	}

	[JsClass("Ext.ComponentLoader", "loader")]
	public interface IComponentLoader
	{
	}

	public interface IToolbarFill: IBase
	{
	}

	public interface ILabel : IBase
	{
	}

	public class Margin: IProvidesValue
	{
		public static implicit operator Margin(string s)
		{
			
			return new Margin {Value = s};
		}

		public object Value { get; private set; }
	}

    [JsClass("Ext.toolbar.Toolbar", "toolbar")]
	public interface IToolbar: IContainer
	{
	}

	public interface IIcone
	{
	}

	 [JsClass("Ext.menu.Item", "menuitem")]
	public interface IMenuItem : IBase
	{
	}

	[JsClass("Ext.menu.Menu", "menu")]
	public interface IMenu : IBase
	{
		void showAt(int[] position);
	}

	public enum SummaryType
	{
		Max,
		Average,
		Sum,
		Min,
		Count
	}

	public enum SortOrder
	{
		Asc,
		Desc
	}

	public interface ISorter
	{
	}

	public interface IColumn
	{
	}

	public interface IViewConfig
	{
	}

    [JsClass("Ext.view.View", "dataview")]
	public interface IView : IAbstractView
	{
	}

	[JsClass("Ext.view.AbstractView", null)]
	public interface IAbstractView : IComponent
	{
	}
}